#ifndef TMROBOTDEF_H
#define TMROBOTDEF_H

#include <IceUtil/PushDisableWarnings.h>
#include <Ice/ProxyF.h>
#include <Ice/ObjectF.h>
#include <Ice/Exception.h>
#include <Ice/LocalObject.h>
#include <Ice/StreamHelpers.h>
#include <Ice/Proxy.h>
#include <Ice/GCObject.h>
#include <Ice/AsyncResult.h>
#include <Ice/Incoming.h>
#include <IceUtil/ScopedArray.h>
#include <IceUtil/Optional.h>
#include <Ice/StreamF.h>
#include <Ice/BuiltinSequences.h>
#include <IceUtil/UndefSysMacros.h>

#ifndef ICE_IGNORE_VERSION
#   if ICE_INT_VERSION / 100 != 306
#       error Ice version mismatch!
#   endif
#   if ICE_INT_VERSION % 100 > 50
#       error Beta header file detected
#   endif
#   if ICE_INT_VERSION % 100 < 3
#       error Ice patch level mismatch!
#   endif
#endif

namespace IceProxy
{

namespace Robot
{

class Json;
void __read(::IceInternal::BasicStream*, ::IceInternal::ProxyHandle< ::IceProxy::Robot::Json>&);
::IceProxy::Ice::Object* upCast(::IceProxy::Robot::Json*);

class Motor;
void __read(::IceInternal::BasicStream*, ::IceInternal::ProxyHandle< ::IceProxy::Robot::Motor>&);
::IceProxy::Ice::Object* upCast(::IceProxy::Robot::Motor*);

class Audio;
void __read(::IceInternal::BasicStream*, ::IceInternal::ProxyHandle< ::IceProxy::Robot::Audio>&);
::IceProxy::Ice::Object* upCast(::IceProxy::Robot::Audio*);

class ScreenEx;
void __read(::IceInternal::BasicStream*, ::IceInternal::ProxyHandle< ::IceProxy::Robot::ScreenEx>&);
::IceProxy::Ice::Object* upCast(::IceProxy::Robot::ScreenEx*);

class Config;
void __read(::IceInternal::BasicStream*, ::IceInternal::ProxyHandle< ::IceProxy::Robot::Config>&);
::IceProxy::Ice::Object* upCast(::IceProxy::Robot::Config*);

class Pub;
void __read(::IceInternal::BasicStream*, ::IceInternal::ProxyHandle< ::IceProxy::Robot::Pub>&);
::IceProxy::Ice::Object* upCast(::IceProxy::Robot::Pub*);

class Session;
void __read(::IceInternal::BasicStream*, ::IceInternal::ProxyHandle< ::IceProxy::Robot::Session>&);
::IceProxy::Ice::Object* upCast(::IceProxy::Robot::Session*);

class Live;
void __read(::IceInternal::BasicStream*, ::IceInternal::ProxyHandle< ::IceProxy::Robot::Live>&);
::IceProxy::Ice::Object* upCast(::IceProxy::Robot::Live*);

}

}

namespace Robot
{

class Json;
::Ice::Object* upCast(::Robot::Json*);
typedef ::IceInternal::Handle< ::Robot::Json> JsonPtr;
typedef ::IceInternal::ProxyHandle< ::IceProxy::Robot::Json> JsonPrx;
void __patch(JsonPtr&, const ::Ice::ObjectPtr&);

class Motor;
::Ice::Object* upCast(::Robot::Motor*);
typedef ::IceInternal::Handle< ::Robot::Motor> MotorPtr;
typedef ::IceInternal::ProxyHandle< ::IceProxy::Robot::Motor> MotorPrx;
void __patch(MotorPtr&, const ::Ice::ObjectPtr&);

class Audio;
::Ice::Object* upCast(::Robot::Audio*);
typedef ::IceInternal::Handle< ::Robot::Audio> AudioPtr;
typedef ::IceInternal::ProxyHandle< ::IceProxy::Robot::Audio> AudioPrx;
void __patch(AudioPtr&, const ::Ice::ObjectPtr&);

class ScreenEx;
::Ice::Object* upCast(::Robot::ScreenEx*);
typedef ::IceInternal::Handle< ::Robot::ScreenEx> ScreenExPtr;
typedef ::IceInternal::ProxyHandle< ::IceProxy::Robot::ScreenEx> ScreenExPrx;
void __patch(ScreenExPtr&, const ::Ice::ObjectPtr&);

class Config;
::Ice::Object* upCast(::Robot::Config*);
typedef ::IceInternal::Handle< ::Robot::Config> ConfigPtr;
typedef ::IceInternal::ProxyHandle< ::IceProxy::Robot::Config> ConfigPrx;
void __patch(ConfigPtr&, const ::Ice::ObjectPtr&);

class Pub;
::Ice::Object* upCast(::Robot::Pub*);
typedef ::IceInternal::Handle< ::Robot::Pub> PubPtr;
typedef ::IceInternal::ProxyHandle< ::IceProxy::Robot::Pub> PubPrx;
void __patch(PubPtr&, const ::Ice::ObjectPtr&);

class Session;
::Ice::Object* upCast(::Robot::Session*);
typedef ::IceInternal::Handle< ::Robot::Session> SessionPtr;
typedef ::IceInternal::ProxyHandle< ::IceProxy::Robot::Session> SessionPrx;
void __patch(SessionPtr&, const ::Ice::ObjectPtr&);

class Live;
::Ice::Object* upCast(::Robot::Live*);
typedef ::IceInternal::Handle< ::Robot::Live> LivePtr;
typedef ::IceInternal::ProxyHandle< ::IceProxy::Robot::Live> LivePrx;
void __patch(LivePtr&, const ::Ice::ObjectPtr&);

}

namespace Robot
{

class Callback_Json_Load_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Json_Load_Base> Callback_Json_LoadPtr;

class Callback_Json_CallByName_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Json_CallByName_Base> Callback_Json_CallByNamePtr;

class Callback_Json_CallByClass_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Json_CallByClass_Base> Callback_Json_CallByClassPtr;

class Callback_Json_CallByContent_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Json_CallByContent_Base> Callback_Json_CallByContentPtr;

class Callback_Json_Stop_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Json_Stop_Base> Callback_Json_StopPtr;

class Callback_Json_IsPlaying_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Json_IsPlaying_Base> Callback_Json_IsPlayingPtr;

class Callback_Json_List_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Json_List_Base> Callback_Json_ListPtr;

class Callback_Motor_SerialWrite_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Motor_SerialWrite_Base> Callback_Motor_SerialWritePtr;

class Callback_Motor_HeadEnable_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Motor_HeadEnable_Base> Callback_Motor_HeadEnablePtr;

class Callback_Motor_HeadLrInit_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Motor_HeadLrInit_Base> Callback_Motor_HeadLrInitPtr;

class Callback_Motor_HeadUdInit_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Motor_HeadUdInit_Base> Callback_Motor_HeadUdInitPtr;

class Callback_Motor_HeadLrAngle_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Motor_HeadLrAngle_Base> Callback_Motor_HeadLrAnglePtr;

class Callback_Motor_HeadUdAngle_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Motor_HeadUdAngle_Base> Callback_Motor_HeadUdAnglePtr;

class Callback_Motor_HandLEnable_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Motor_HandLEnable_Base> Callback_Motor_HandLEnablePtr;

class Callback_Motor_HandLSwingInit_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Motor_HandLSwingInit_Base> Callback_Motor_HandLSwingInitPtr;

class Callback_Motor_HandLExpandInit_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Motor_HandLExpandInit_Base> Callback_Motor_HandLExpandInitPtr;

class Callback_Motor_HandLSwingAngle_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Motor_HandLSwingAngle_Base> Callback_Motor_HandLSwingAnglePtr;

class Callback_Motor_HandLExpandAngle_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Motor_HandLExpandAngle_Base> Callback_Motor_HandLExpandAnglePtr;

class Callback_Motor_HandREnable_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Motor_HandREnable_Base> Callback_Motor_HandREnablePtr;

class Callback_Motor_HandRSwingInit_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Motor_HandRSwingInit_Base> Callback_Motor_HandRSwingInitPtr;

class Callback_Motor_HandRExpandInit_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Motor_HandRExpandInit_Base> Callback_Motor_HandRExpandInitPtr;

class Callback_Motor_HandRSwingAngle_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Motor_HandRSwingAngle_Base> Callback_Motor_HandRSwingAnglePtr;

class Callback_Motor_HandRExpandAngle_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Motor_HandRExpandAngle_Base> Callback_Motor_HandRExpandAnglePtr;

class Callback_Motor_WheelEnable_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Motor_WheelEnable_Base> Callback_Motor_WheelEnablePtr;

class Callback_Motor_WheelStop_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Motor_WheelStop_Base> Callback_Motor_WheelStopPtr;

class Callback_Motor_WheelRotate_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Motor_WheelRotate_Base> Callback_Motor_WheelRotatePtr;

class Callback_Motor_WheelRun_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Motor_WheelRun_Base> Callback_Motor_WheelRunPtr;

class Callback_Motor_WheelRunDiff_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Motor_WheelRunDiff_Base> Callback_Motor_WheelRunDiffPtr;

class Callback_Motor_HeadEye_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Motor_HeadEye_Base> Callback_Motor_HeadEyePtr;

class Callback_Motor_HeadEye2_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Motor_HeadEye2_Base> Callback_Motor_HeadEye2Ptr;

class Callback_Motor_HeadEar_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Motor_HeadEar_Base> Callback_Motor_HeadEarPtr;

class Callback_Motor_BodyLed_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Motor_BodyLed_Base> Callback_Motor_BodyLedPtr;

class Callback_Motor_TouchSet_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Motor_TouchSet_Base> Callback_Motor_TouchSetPtr;

class Callback_Motor_SensorBatteryValue_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Motor_SensorBatteryValue_Base> Callback_Motor_SensorBatteryValuePtr;

class Callback_Motor_SensorSonicValue_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Motor_SensorSonicValue_Base> Callback_Motor_SensorSonicValuePtr;

class Callback_Motor_SensorInfraredValue_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Motor_SensorInfraredValue_Base> Callback_Motor_SensorInfraredValuePtr;

class Callback_Motor_SetProtect_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Motor_SetProtect_Base> Callback_Motor_SetProtectPtr;

class Callback_Motor_GetProtect_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Motor_GetProtect_Base> Callback_Motor_GetProtectPtr;

class Callback_Audio_TtsPlayParams_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Audio_TtsPlayParams_Base> Callback_Audio_TtsPlayParamsPtr;

class Callback_Audio_TtsPlay_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Audio_TtsPlay_Base> Callback_Audio_TtsPlayPtr;

class Callback_Audio_TtsPlayFile_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Audio_TtsPlayFile_Base> Callback_Audio_TtsPlayFilePtr;

class Callback_Audio_TtsSetVolume_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Audio_TtsSetVolume_Base> Callback_Audio_TtsSetVolumePtr;

class Callback_Audio_TtsStop_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Audio_TtsStop_Base> Callback_Audio_TtsStopPtr;

class Callback_Audio_TtsIsPlaying_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Audio_TtsIsPlaying_Base> Callback_Audio_TtsIsPlayingPtr;

class Callback_Audio_AsrBuildCmd_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Audio_AsrBuildCmd_Base> Callback_Audio_AsrBuildCmdPtr;

class Callback_Audio_AsrStart_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Audio_AsrStart_Base> Callback_Audio_AsrStartPtr;

class Callback_Audio_AsrStop_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Audio_AsrStop_Base> Callback_Audio_AsrStopPtr;

class Callback_Audio_MediaPlay_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Audio_MediaPlay_Base> Callback_Audio_MediaPlayPtr;

class Callback_Audio_MediaSetVolume_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Audio_MediaSetVolume_Base> Callback_Audio_MediaSetVolumePtr;

class Callback_Audio_MediaStop_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Audio_MediaStop_Base> Callback_Audio_MediaStopPtr;

class Callback_Audio_MediaIsPlaying_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Audio_MediaIsPlaying_Base> Callback_Audio_MediaIsPlayingPtr;

class Callback_ScreenEx_ShowRepeatDir_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_ScreenEx_ShowRepeatDir_Base> Callback_ScreenEx_ShowRepeatDirPtr;

class Callback_ScreenEx_ShowPic_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_ScreenEx_ShowPic_Base> Callback_ScreenEx_ShowPicPtr;

class Callback_ScreenEx_ShowVideo_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_ScreenEx_ShowVideo_Base> Callback_ScreenEx_ShowVideoPtr;

class Callback_ScreenEx_Clean_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_ScreenEx_Clean_Base> Callback_ScreenEx_CleanPtr;

class Callback_ScreenEx_ShowVip_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_ScreenEx_ShowVip_Base> Callback_ScreenEx_ShowVipPtr;

class Callback_ScreenEx_ShowBarrage_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_ScreenEx_ShowBarrage_Base> Callback_ScreenEx_ShowBarragePtr;

class Callback_Config_SetSystemVolume_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Config_SetSystemVolume_Base> Callback_Config_SetSystemVolumePtr;

class Callback_Config_GetSystemVolume_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Config_GetSystemVolume_Base> Callback_Config_GetSystemVolumePtr;

class Callback_Config_SetSystemCmd_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Config_SetSystemCmd_Base> Callback_Config_SetSystemCmdPtr;

class Callback_Pub_Notify_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Pub_Notify_Base> Callback_Pub_NotifyPtr;

class Callback_Session_List_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Session_List_Base> Callback_Session_ListPtr;

class Callback_Live_RemoteRecvStart_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Live_RemoteRecvStart_Base> Callback_Live_RemoteRecvStartPtr;

class Callback_Live_RemoteRecvStop_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Live_RemoteRecvStop_Base> Callback_Live_RemoteRecvStopPtr;

}

namespace IceProxy
{

namespace Robot
{

class Json : virtual public ::IceProxy::Ice::Object
{
public:

    bool Load(const ::std::string& __p_strPath)
    {
        return Load(__p_strPath, 0);
    }
    bool Load(const ::std::string& __p_strPath, const ::Ice::Context& __ctx)
    {
        return Load(__p_strPath, &__ctx);
    }
#ifdef ICE_CPP11
    ::Ice::AsyncResultPtr
    begin_Load(const ::std::string& __p_strPath, const ::IceInternal::Function<void (bool)>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return __begin_Load(__p_strPath, 0, __response, __exception, __sent);
    }
    ::Ice::AsyncResultPtr
    begin_Load(const ::std::string& __p_strPath, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_Load(__p_strPath, 0, ::Ice::newCallback(__completed, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_Load(const ::std::string& __p_strPath, const ::Ice::Context& __ctx, const ::IceInternal::Function<void (bool)>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return __begin_Load(__p_strPath, &__ctx, __response, __exception, __sent);
    }
    ::Ice::AsyncResultPtr
    begin_Load(const ::std::string& __p_strPath, const ::Ice::Context& __ctx, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_Load(__p_strPath, &__ctx, ::Ice::newCallback(__completed, __sent));
    }

private:

    ::Ice::AsyncResultPtr __begin_Load(const ::std::string& __p_strPath, const ::Ice::Context* __ctx, const ::IceInternal::Function<void (bool)>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception, const ::IceInternal::Function<void (bool)>& __sent);

public:
#endif

    ::Ice::AsyncResultPtr begin_Load(const ::std::string& __p_strPath)
    {
        return begin_Load(__p_strPath, 0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_Load(const ::std::string& __p_strPath, const ::Ice::Context& __ctx)
    {
        return begin_Load(__p_strPath, &__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_Load(const ::std::string& __p_strPath, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_Load(__p_strPath, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_Load(const ::std::string& __p_strPath, const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_Load(__p_strPath, &__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_Load(const ::std::string& __p_strPath, const ::Robot::Callback_Json_LoadPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_Load(__p_strPath, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_Load(const ::std::string& __p_strPath, const ::Ice::Context& __ctx, const ::Robot::Callback_Json_LoadPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_Load(__p_strPath, &__ctx, __del, __cookie);
    }

    bool end_Load(const ::Ice::AsyncResultPtr&);

private:

    bool Load(const ::std::string&, const ::Ice::Context*);
    ::Ice::AsyncResultPtr begin_Load(const ::std::string&, const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);

public:

    void CallByName(const ::std::string& __p_strName)
    {
        CallByName(__p_strName, 0);
    }
    void CallByName(const ::std::string& __p_strName, const ::Ice::Context& __ctx)
    {
        CallByName(__p_strName, &__ctx);
    }
#ifdef ICE_CPP11
    ::Ice::AsyncResultPtr
    begin_CallByName(const ::std::string& __p_strName, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_CallByName(__p_strName, 0, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent));
    }
    ::Ice::AsyncResultPtr
    begin_CallByName(const ::std::string& __p_strName, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_CallByName(__p_strName, 0, ::Ice::newCallback(__completed, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_CallByName(const ::std::string& __p_strName, const ::Ice::Context& __ctx, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_CallByName(__p_strName, &__ctx, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_CallByName(const ::std::string& __p_strName, const ::Ice::Context& __ctx, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_CallByName(__p_strName, &__ctx, ::Ice::newCallback(__completed, __sent));
    }
#endif

    ::Ice::AsyncResultPtr begin_CallByName(const ::std::string& __p_strName)
    {
        return begin_CallByName(__p_strName, 0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_CallByName(const ::std::string& __p_strName, const ::Ice::Context& __ctx)
    {
        return begin_CallByName(__p_strName, &__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_CallByName(const ::std::string& __p_strName, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_CallByName(__p_strName, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_CallByName(const ::std::string& __p_strName, const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_CallByName(__p_strName, &__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_CallByName(const ::std::string& __p_strName, const ::Robot::Callback_Json_CallByNamePtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_CallByName(__p_strName, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_CallByName(const ::std::string& __p_strName, const ::Ice::Context& __ctx, const ::Robot::Callback_Json_CallByNamePtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_CallByName(__p_strName, &__ctx, __del, __cookie);
    }

    void end_CallByName(const ::Ice::AsyncResultPtr&);

private:

    void CallByName(const ::std::string&, const ::Ice::Context*);
    ::Ice::AsyncResultPtr begin_CallByName(const ::std::string&, const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);

public:

    void CallByClass(const ::std::string& __p_strClassName)
    {
        CallByClass(__p_strClassName, 0);
    }
    void CallByClass(const ::std::string& __p_strClassName, const ::Ice::Context& __ctx)
    {
        CallByClass(__p_strClassName, &__ctx);
    }
#ifdef ICE_CPP11
    ::Ice::AsyncResultPtr
    begin_CallByClass(const ::std::string& __p_strClassName, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_CallByClass(__p_strClassName, 0, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent));
    }
    ::Ice::AsyncResultPtr
    begin_CallByClass(const ::std::string& __p_strClassName, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_CallByClass(__p_strClassName, 0, ::Ice::newCallback(__completed, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_CallByClass(const ::std::string& __p_strClassName, const ::Ice::Context& __ctx, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_CallByClass(__p_strClassName, &__ctx, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_CallByClass(const ::std::string& __p_strClassName, const ::Ice::Context& __ctx, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_CallByClass(__p_strClassName, &__ctx, ::Ice::newCallback(__completed, __sent));
    }
#endif

    ::Ice::AsyncResultPtr begin_CallByClass(const ::std::string& __p_strClassName)
    {
        return begin_CallByClass(__p_strClassName, 0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_CallByClass(const ::std::string& __p_strClassName, const ::Ice::Context& __ctx)
    {
        return begin_CallByClass(__p_strClassName, &__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_CallByClass(const ::std::string& __p_strClassName, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_CallByClass(__p_strClassName, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_CallByClass(const ::std::string& __p_strClassName, const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_CallByClass(__p_strClassName, &__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_CallByClass(const ::std::string& __p_strClassName, const ::Robot::Callback_Json_CallByClassPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_CallByClass(__p_strClassName, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_CallByClass(const ::std::string& __p_strClassName, const ::Ice::Context& __ctx, const ::Robot::Callback_Json_CallByClassPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_CallByClass(__p_strClassName, &__ctx, __del, __cookie);
    }

    void end_CallByClass(const ::Ice::AsyncResultPtr&);

private:

    void CallByClass(const ::std::string&, const ::Ice::Context*);
    ::Ice::AsyncResultPtr begin_CallByClass(const ::std::string&, const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);

public:

    void CallByContent(const ::std::string& __p_strBase64)
    {
        CallByContent(__p_strBase64, 0);
    }
    void CallByContent(const ::std::string& __p_strBase64, const ::Ice::Context& __ctx)
    {
        CallByContent(__p_strBase64, &__ctx);
    }
#ifdef ICE_CPP11
    ::Ice::AsyncResultPtr
    begin_CallByContent(const ::std::string& __p_strBase64, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_CallByContent(__p_strBase64, 0, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent));
    }
    ::Ice::AsyncResultPtr
    begin_CallByContent(const ::std::string& __p_strBase64, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_CallByContent(__p_strBase64, 0, ::Ice::newCallback(__completed, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_CallByContent(const ::std::string& __p_strBase64, const ::Ice::Context& __ctx, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_CallByContent(__p_strBase64, &__ctx, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_CallByContent(const ::std::string& __p_strBase64, const ::Ice::Context& __ctx, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_CallByContent(__p_strBase64, &__ctx, ::Ice::newCallback(__completed, __sent));
    }
#endif

    ::Ice::AsyncResultPtr begin_CallByContent(const ::std::string& __p_strBase64)
    {
        return begin_CallByContent(__p_strBase64, 0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_CallByContent(const ::std::string& __p_strBase64, const ::Ice::Context& __ctx)
    {
        return begin_CallByContent(__p_strBase64, &__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_CallByContent(const ::std::string& __p_strBase64, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_CallByContent(__p_strBase64, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_CallByContent(const ::std::string& __p_strBase64, const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_CallByContent(__p_strBase64, &__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_CallByContent(const ::std::string& __p_strBase64, const ::Robot::Callback_Json_CallByContentPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_CallByContent(__p_strBase64, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_CallByContent(const ::std::string& __p_strBase64, const ::Ice::Context& __ctx, const ::Robot::Callback_Json_CallByContentPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_CallByContent(__p_strBase64, &__ctx, __del, __cookie);
    }

    void end_CallByContent(const ::Ice::AsyncResultPtr&);

private:

    void CallByContent(const ::std::string&, const ::Ice::Context*);
    ::Ice::AsyncResultPtr begin_CallByContent(const ::std::string&, const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);

public:

    void Stop()
    {
        Stop(0);
    }
    void Stop(const ::Ice::Context& __ctx)
    {
        Stop(&__ctx);
    }
#ifdef ICE_CPP11
    ::Ice::AsyncResultPtr
    begin_Stop(const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_Stop(0, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent));
    }
    ::Ice::AsyncResultPtr
    begin_Stop(const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_Stop(0, ::Ice::newCallback(__completed, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_Stop(const ::Ice::Context& __ctx, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_Stop(&__ctx, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_Stop(const ::Ice::Context& __ctx, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_Stop(&__ctx, ::Ice::newCallback(__completed, __sent));
    }
#endif

    ::Ice::AsyncResultPtr begin_Stop()
    {
        return begin_Stop(0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_Stop(const ::Ice::Context& __ctx)
    {
        return begin_Stop(&__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_Stop(const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_Stop(0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_Stop(const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_Stop(&__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_Stop(const ::Robot::Callback_Json_StopPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_Stop(0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_Stop(const ::Ice::Context& __ctx, const ::Robot::Callback_Json_StopPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_Stop(&__ctx, __del, __cookie);
    }

    void end_Stop(const ::Ice::AsyncResultPtr&);

private:

    void Stop(const ::Ice::Context*);
    ::Ice::AsyncResultPtr begin_Stop(const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);

public:

    bool IsPlaying()
    {
        return IsPlaying(0);
    }
    bool IsPlaying(const ::Ice::Context& __ctx)
    {
        return IsPlaying(&__ctx);
    }
#ifdef ICE_CPP11
    ::Ice::AsyncResultPtr
    begin_IsPlaying(const ::IceInternal::Function<void (bool)>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return __begin_IsPlaying(0, __response, __exception, __sent);
    }
    ::Ice::AsyncResultPtr
    begin_IsPlaying(const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_IsPlaying(0, ::Ice::newCallback(__completed, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_IsPlaying(const ::Ice::Context& __ctx, const ::IceInternal::Function<void (bool)>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return __begin_IsPlaying(&__ctx, __response, __exception, __sent);
    }
    ::Ice::AsyncResultPtr
    begin_IsPlaying(const ::Ice::Context& __ctx, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_IsPlaying(&__ctx, ::Ice::newCallback(__completed, __sent));
    }

private:

    ::Ice::AsyncResultPtr __begin_IsPlaying(const ::Ice::Context* __ctx, const ::IceInternal::Function<void (bool)>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception, const ::IceInternal::Function<void (bool)>& __sent);

public:
#endif

    ::Ice::AsyncResultPtr begin_IsPlaying()
    {
        return begin_IsPlaying(0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_IsPlaying(const ::Ice::Context& __ctx)
    {
        return begin_IsPlaying(&__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_IsPlaying(const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_IsPlaying(0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_IsPlaying(const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_IsPlaying(&__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_IsPlaying(const ::Robot::Callback_Json_IsPlayingPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_IsPlaying(0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_IsPlaying(const ::Ice::Context& __ctx, const ::Robot::Callback_Json_IsPlayingPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_IsPlaying(&__ctx, __del, __cookie);
    }

    bool end_IsPlaying(const ::Ice::AsyncResultPtr&);

private:

    bool IsPlaying(const ::Ice::Context*);
    ::Ice::AsyncResultPtr begin_IsPlaying(const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);

public:

    void List(::Ice::StringSeq& __p_strList)
    {
        List(__p_strList, 0);
    }
    void List(::Ice::StringSeq& __p_strList, const ::Ice::Context& __ctx)
    {
        List(__p_strList, &__ctx);
    }
#ifdef ICE_CPP11
    ::Ice::AsyncResultPtr
    begin_List(const ::IceInternal::Function<void (const ::Ice::StringSeq&)>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return __begin_List(0, __response, __exception, __sent);
    }
    ::Ice::AsyncResultPtr
    begin_List(const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_List(0, ::Ice::newCallback(__completed, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_List(const ::Ice::Context& __ctx, const ::IceInternal::Function<void (const ::Ice::StringSeq&)>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return __begin_List(&__ctx, __response, __exception, __sent);
    }
    ::Ice::AsyncResultPtr
    begin_List(const ::Ice::Context& __ctx, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_List(&__ctx, ::Ice::newCallback(__completed, __sent));
    }

private:

    ::Ice::AsyncResultPtr __begin_List(const ::Ice::Context* __ctx, const ::IceInternal::Function<void (const ::Ice::StringSeq&)>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception, const ::IceInternal::Function<void (bool)>& __sent);

public:
#endif

    ::Ice::AsyncResultPtr begin_List()
    {
        return begin_List(0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_List(const ::Ice::Context& __ctx)
    {
        return begin_List(&__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_List(const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_List(0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_List(const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_List(&__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_List(const ::Robot::Callback_Json_ListPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_List(0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_List(const ::Ice::Context& __ctx, const ::Robot::Callback_Json_ListPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_List(&__ctx, __del, __cookie);
    }

    void end_List(::Ice::StringSeq& __p_strList, const ::Ice::AsyncResultPtr&);

private:

    void List(::Ice::StringSeq&, const ::Ice::Context*);
    ::Ice::AsyncResultPtr begin_List(const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);

public:

    ::IceInternal::ProxyHandle<Json> ice_context(const ::Ice::Context& __context) const
    {
        return dynamic_cast<Json*>(::IceProxy::Ice::Object::ice_context(__context).get());
    }

    ::IceInternal::ProxyHandle<Json> ice_adapterId(const ::std::string& __id) const
    {
        return dynamic_cast<Json*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
    }

    ::IceInternal::ProxyHandle<Json> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
    {
        return dynamic_cast<Json*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
    }

    ::IceInternal::ProxyHandle<Json> ice_locatorCacheTimeout(int __timeout) const
    {
        return dynamic_cast<Json*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
    }

    ::IceInternal::ProxyHandle<Json> ice_connectionCached(bool __cached) const
    {
        return dynamic_cast<Json*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
    }

    ::IceInternal::ProxyHandle<Json> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
    {
        return dynamic_cast<Json*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
    }

    ::IceInternal::ProxyHandle<Json> ice_secure(bool __secure) const
    {
        return dynamic_cast<Json*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
    }

    ::IceInternal::ProxyHandle<Json> ice_preferSecure(bool __preferSecure) const
    {
        return dynamic_cast<Json*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
    }

    ::IceInternal::ProxyHandle<Json> ice_router(const ::Ice::RouterPrx& __router) const
    {
        return dynamic_cast<Json*>(::IceProxy::Ice::Object::ice_router(__router).get());
    }

    ::IceInternal::ProxyHandle<Json> ice_locator(const ::Ice::LocatorPrx& __locator) const
    {
        return dynamic_cast<Json*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
    }

    ::IceInternal::ProxyHandle<Json> ice_collocationOptimized(bool __co) const
    {
        return dynamic_cast<Json*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
    }

    ::IceInternal::ProxyHandle<Json> ice_invocationTimeout(int __timeout) const
    {
        return dynamic_cast<Json*>(::IceProxy::Ice::Object::ice_invocationTimeout(__timeout).get());
    }

    ::IceInternal::ProxyHandle<Json> ice_twoway() const
    {
        return dynamic_cast<Json*>(::IceProxy::Ice::Object::ice_twoway().get());
    }

    ::IceInternal::ProxyHandle<Json> ice_oneway() const
    {
        return dynamic_cast<Json*>(::IceProxy::Ice::Object::ice_oneway().get());
    }

    ::IceInternal::ProxyHandle<Json> ice_batchOneway() const
    {
        return dynamic_cast<Json*>(::IceProxy::Ice::Object::ice_batchOneway().get());
    }

    ::IceInternal::ProxyHandle<Json> ice_datagram() const
    {
        return dynamic_cast<Json*>(::IceProxy::Ice::Object::ice_datagram().get());
    }

    ::IceInternal::ProxyHandle<Json> ice_batchDatagram() const
    {
        return dynamic_cast<Json*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
    }

    ::IceInternal::ProxyHandle<Json> ice_compress(bool __compress) const
    {
        return dynamic_cast<Json*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
    }

    ::IceInternal::ProxyHandle<Json> ice_timeout(int __timeout) const
    {
        return dynamic_cast<Json*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
    }

    ::IceInternal::ProxyHandle<Json> ice_connectionId(const ::std::string& __id) const
    {
        return dynamic_cast<Json*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
    }

    ::IceInternal::ProxyHandle<Json> ice_encodingVersion(const ::Ice::EncodingVersion& __v) const
    {
        return dynamic_cast<Json*>(::IceProxy::Ice::Object::ice_encodingVersion(__v).get());
    }

    static const ::std::string& ice_staticId();

private:
    virtual ::IceProxy::Ice::Object* __newInstance() const;
};

class Motor : virtual public ::IceProxy::Ice::Object
{
public:

    void SerialWrite(const ::Ice::ByteSeq& __p_bHexData)
    {
        SerialWrite(__p_bHexData, 0);
    }
    void SerialWrite(const ::Ice::ByteSeq& __p_bHexData, const ::Ice::Context& __ctx)
    {
        SerialWrite(__p_bHexData, &__ctx);
    }
#ifdef ICE_CPP11
    ::Ice::AsyncResultPtr
    begin_SerialWrite(const ::Ice::ByteSeq& __p_bHexData, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_SerialWrite(__p_bHexData, 0, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent));
    }
    ::Ice::AsyncResultPtr
    begin_SerialWrite(const ::Ice::ByteSeq& __p_bHexData, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_SerialWrite(__p_bHexData, 0, ::Ice::newCallback(__completed, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_SerialWrite(const ::Ice::ByteSeq& __p_bHexData, const ::Ice::Context& __ctx, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_SerialWrite(__p_bHexData, &__ctx, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_SerialWrite(const ::Ice::ByteSeq& __p_bHexData, const ::Ice::Context& __ctx, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_SerialWrite(__p_bHexData, &__ctx, ::Ice::newCallback(__completed, __sent));
    }
#endif

    ::Ice::AsyncResultPtr begin_SerialWrite(const ::Ice::ByteSeq& __p_bHexData)
    {
        return begin_SerialWrite(__p_bHexData, 0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_SerialWrite(const ::Ice::ByteSeq& __p_bHexData, const ::Ice::Context& __ctx)
    {
        return begin_SerialWrite(__p_bHexData, &__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_SerialWrite(const ::Ice::ByteSeq& __p_bHexData, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_SerialWrite(__p_bHexData, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_SerialWrite(const ::Ice::ByteSeq& __p_bHexData, const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_SerialWrite(__p_bHexData, &__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_SerialWrite(const ::Ice::ByteSeq& __p_bHexData, const ::Robot::Callback_Motor_SerialWritePtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_SerialWrite(__p_bHexData, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_SerialWrite(const ::Ice::ByteSeq& __p_bHexData, const ::Ice::Context& __ctx, const ::Robot::Callback_Motor_SerialWritePtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_SerialWrite(__p_bHexData, &__ctx, __del, __cookie);
    }

    void end_SerialWrite(const ::Ice::AsyncResultPtr&);

private:

    void SerialWrite(const ::Ice::ByteSeq&, const ::Ice::Context*);
    ::Ice::AsyncResultPtr begin_SerialWrite(const ::Ice::ByteSeq&, const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);

public:

    void HeadEnable(bool __p_bLR, bool __p_bUD)
    {
        HeadEnable(__p_bLR, __p_bUD, 0);
    }
    void HeadEnable(bool __p_bLR, bool __p_bUD, const ::Ice::Context& __ctx)
    {
        HeadEnable(__p_bLR, __p_bUD, &__ctx);
    }
#ifdef ICE_CPP11
    ::Ice::AsyncResultPtr
    begin_HeadEnable(bool __p_bLR, bool __p_bUD, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_HeadEnable(__p_bLR, __p_bUD, 0, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent));
    }
    ::Ice::AsyncResultPtr
    begin_HeadEnable(bool __p_bLR, bool __p_bUD, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_HeadEnable(__p_bLR, __p_bUD, 0, ::Ice::newCallback(__completed, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_HeadEnable(bool __p_bLR, bool __p_bUD, const ::Ice::Context& __ctx, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_HeadEnable(__p_bLR, __p_bUD, &__ctx, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_HeadEnable(bool __p_bLR, bool __p_bUD, const ::Ice::Context& __ctx, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_HeadEnable(__p_bLR, __p_bUD, &__ctx, ::Ice::newCallback(__completed, __sent));
    }
#endif

    ::Ice::AsyncResultPtr begin_HeadEnable(bool __p_bLR, bool __p_bUD)
    {
        return begin_HeadEnable(__p_bLR, __p_bUD, 0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_HeadEnable(bool __p_bLR, bool __p_bUD, const ::Ice::Context& __ctx)
    {
        return begin_HeadEnable(__p_bLR, __p_bUD, &__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_HeadEnable(bool __p_bLR, bool __p_bUD, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_HeadEnable(__p_bLR, __p_bUD, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_HeadEnable(bool __p_bLR, bool __p_bUD, const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_HeadEnable(__p_bLR, __p_bUD, &__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_HeadEnable(bool __p_bLR, bool __p_bUD, const ::Robot::Callback_Motor_HeadEnablePtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_HeadEnable(__p_bLR, __p_bUD, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_HeadEnable(bool __p_bLR, bool __p_bUD, const ::Ice::Context& __ctx, const ::Robot::Callback_Motor_HeadEnablePtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_HeadEnable(__p_bLR, __p_bUD, &__ctx, __del, __cookie);
    }

    void end_HeadEnable(const ::Ice::AsyncResultPtr&);

private:

    void HeadEnable(bool, bool, const ::Ice::Context*);
    ::Ice::AsyncResultPtr begin_HeadEnable(bool, bool, const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);

public:

    void HeadLrInit()
    {
        HeadLrInit(0);
    }
    void HeadLrInit(const ::Ice::Context& __ctx)
    {
        HeadLrInit(&__ctx);
    }
#ifdef ICE_CPP11
    ::Ice::AsyncResultPtr
    begin_HeadLrInit(const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_HeadLrInit(0, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent));
    }
    ::Ice::AsyncResultPtr
    begin_HeadLrInit(const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_HeadLrInit(0, ::Ice::newCallback(__completed, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_HeadLrInit(const ::Ice::Context& __ctx, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_HeadLrInit(&__ctx, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_HeadLrInit(const ::Ice::Context& __ctx, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_HeadLrInit(&__ctx, ::Ice::newCallback(__completed, __sent));
    }
#endif

    ::Ice::AsyncResultPtr begin_HeadLrInit()
    {
        return begin_HeadLrInit(0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_HeadLrInit(const ::Ice::Context& __ctx)
    {
        return begin_HeadLrInit(&__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_HeadLrInit(const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_HeadLrInit(0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_HeadLrInit(const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_HeadLrInit(&__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_HeadLrInit(const ::Robot::Callback_Motor_HeadLrInitPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_HeadLrInit(0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_HeadLrInit(const ::Ice::Context& __ctx, const ::Robot::Callback_Motor_HeadLrInitPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_HeadLrInit(&__ctx, __del, __cookie);
    }

    void end_HeadLrInit(const ::Ice::AsyncResultPtr&);

private:

    void HeadLrInit(const ::Ice::Context*);
    ::Ice::AsyncResultPtr begin_HeadLrInit(const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);

public:

    void HeadUdInit()
    {
        HeadUdInit(0);
    }
    void HeadUdInit(const ::Ice::Context& __ctx)
    {
        HeadUdInit(&__ctx);
    }
#ifdef ICE_CPP11
    ::Ice::AsyncResultPtr
    begin_HeadUdInit(const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_HeadUdInit(0, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent));
    }
    ::Ice::AsyncResultPtr
    begin_HeadUdInit(const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_HeadUdInit(0, ::Ice::newCallback(__completed, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_HeadUdInit(const ::Ice::Context& __ctx, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_HeadUdInit(&__ctx, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_HeadUdInit(const ::Ice::Context& __ctx, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_HeadUdInit(&__ctx, ::Ice::newCallback(__completed, __sent));
    }
#endif

    ::Ice::AsyncResultPtr begin_HeadUdInit()
    {
        return begin_HeadUdInit(0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_HeadUdInit(const ::Ice::Context& __ctx)
    {
        return begin_HeadUdInit(&__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_HeadUdInit(const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_HeadUdInit(0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_HeadUdInit(const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_HeadUdInit(&__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_HeadUdInit(const ::Robot::Callback_Motor_HeadUdInitPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_HeadUdInit(0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_HeadUdInit(const ::Ice::Context& __ctx, const ::Robot::Callback_Motor_HeadUdInitPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_HeadUdInit(&__ctx, __del, __cookie);
    }

    void end_HeadUdInit(const ::Ice::AsyncResultPtr&);

private:

    void HeadUdInit(const ::Ice::Context*);
    ::Ice::AsyncResultPtr begin_HeadUdInit(const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);

public:

    void HeadLrAngle(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed)
    {
        HeadLrAngle(__p_nAngle, __p_nSpeed, 0);
    }
    void HeadLrAngle(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed, const ::Ice::Context& __ctx)
    {
        HeadLrAngle(__p_nAngle, __p_nSpeed, &__ctx);
    }
#ifdef ICE_CPP11
    ::Ice::AsyncResultPtr
    begin_HeadLrAngle(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_HeadLrAngle(__p_nAngle, __p_nSpeed, 0, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent));
    }
    ::Ice::AsyncResultPtr
    begin_HeadLrAngle(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_HeadLrAngle(__p_nAngle, __p_nSpeed, 0, ::Ice::newCallback(__completed, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_HeadLrAngle(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed, const ::Ice::Context& __ctx, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_HeadLrAngle(__p_nAngle, __p_nSpeed, &__ctx, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_HeadLrAngle(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed, const ::Ice::Context& __ctx, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_HeadLrAngle(__p_nAngle, __p_nSpeed, &__ctx, ::Ice::newCallback(__completed, __sent));
    }
#endif

    ::Ice::AsyncResultPtr begin_HeadLrAngle(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed)
    {
        return begin_HeadLrAngle(__p_nAngle, __p_nSpeed, 0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_HeadLrAngle(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed, const ::Ice::Context& __ctx)
    {
        return begin_HeadLrAngle(__p_nAngle, __p_nSpeed, &__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_HeadLrAngle(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_HeadLrAngle(__p_nAngle, __p_nSpeed, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_HeadLrAngle(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed, const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_HeadLrAngle(__p_nAngle, __p_nSpeed, &__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_HeadLrAngle(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed, const ::Robot::Callback_Motor_HeadLrAnglePtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_HeadLrAngle(__p_nAngle, __p_nSpeed, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_HeadLrAngle(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed, const ::Ice::Context& __ctx, const ::Robot::Callback_Motor_HeadLrAnglePtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_HeadLrAngle(__p_nAngle, __p_nSpeed, &__ctx, __del, __cookie);
    }

    void end_HeadLrAngle(const ::Ice::AsyncResultPtr&);

private:

    void HeadLrAngle(::Ice::Int, ::Ice::Int, const ::Ice::Context*);
    ::Ice::AsyncResultPtr begin_HeadLrAngle(::Ice::Int, ::Ice::Int, const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);

public:

    void HeadUdAngle(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed)
    {
        HeadUdAngle(__p_nAngle, __p_nSpeed, 0);
    }
    void HeadUdAngle(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed, const ::Ice::Context& __ctx)
    {
        HeadUdAngle(__p_nAngle, __p_nSpeed, &__ctx);
    }
#ifdef ICE_CPP11
    ::Ice::AsyncResultPtr
    begin_HeadUdAngle(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_HeadUdAngle(__p_nAngle, __p_nSpeed, 0, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent));
    }
    ::Ice::AsyncResultPtr
    begin_HeadUdAngle(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_HeadUdAngle(__p_nAngle, __p_nSpeed, 0, ::Ice::newCallback(__completed, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_HeadUdAngle(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed, const ::Ice::Context& __ctx, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_HeadUdAngle(__p_nAngle, __p_nSpeed, &__ctx, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_HeadUdAngle(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed, const ::Ice::Context& __ctx, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_HeadUdAngle(__p_nAngle, __p_nSpeed, &__ctx, ::Ice::newCallback(__completed, __sent));
    }
#endif

    ::Ice::AsyncResultPtr begin_HeadUdAngle(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed)
    {
        return begin_HeadUdAngle(__p_nAngle, __p_nSpeed, 0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_HeadUdAngle(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed, const ::Ice::Context& __ctx)
    {
        return begin_HeadUdAngle(__p_nAngle, __p_nSpeed, &__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_HeadUdAngle(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_HeadUdAngle(__p_nAngle, __p_nSpeed, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_HeadUdAngle(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed, const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_HeadUdAngle(__p_nAngle, __p_nSpeed, &__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_HeadUdAngle(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed, const ::Robot::Callback_Motor_HeadUdAnglePtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_HeadUdAngle(__p_nAngle, __p_nSpeed, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_HeadUdAngle(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed, const ::Ice::Context& __ctx, const ::Robot::Callback_Motor_HeadUdAnglePtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_HeadUdAngle(__p_nAngle, __p_nSpeed, &__ctx, __del, __cookie);
    }

    void end_HeadUdAngle(const ::Ice::AsyncResultPtr&);

private:

    void HeadUdAngle(::Ice::Int, ::Ice::Int, const ::Ice::Context*);
    ::Ice::AsyncResultPtr begin_HeadUdAngle(::Ice::Int, ::Ice::Int, const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);

public:

    void HandLEnable(bool __p_bSwing, bool __p_bExpand)
    {
        HandLEnable(__p_bSwing, __p_bExpand, 0);
    }
    void HandLEnable(bool __p_bSwing, bool __p_bExpand, const ::Ice::Context& __ctx)
    {
        HandLEnable(__p_bSwing, __p_bExpand, &__ctx);
    }
#ifdef ICE_CPP11
    ::Ice::AsyncResultPtr
    begin_HandLEnable(bool __p_bSwing, bool __p_bExpand, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_HandLEnable(__p_bSwing, __p_bExpand, 0, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent));
    }
    ::Ice::AsyncResultPtr
    begin_HandLEnable(bool __p_bSwing, bool __p_bExpand, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_HandLEnable(__p_bSwing, __p_bExpand, 0, ::Ice::newCallback(__completed, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_HandLEnable(bool __p_bSwing, bool __p_bExpand, const ::Ice::Context& __ctx, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_HandLEnable(__p_bSwing, __p_bExpand, &__ctx, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_HandLEnable(bool __p_bSwing, bool __p_bExpand, const ::Ice::Context& __ctx, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_HandLEnable(__p_bSwing, __p_bExpand, &__ctx, ::Ice::newCallback(__completed, __sent));
    }
#endif

    ::Ice::AsyncResultPtr begin_HandLEnable(bool __p_bSwing, bool __p_bExpand)
    {
        return begin_HandLEnable(__p_bSwing, __p_bExpand, 0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_HandLEnable(bool __p_bSwing, bool __p_bExpand, const ::Ice::Context& __ctx)
    {
        return begin_HandLEnable(__p_bSwing, __p_bExpand, &__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_HandLEnable(bool __p_bSwing, bool __p_bExpand, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_HandLEnable(__p_bSwing, __p_bExpand, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_HandLEnable(bool __p_bSwing, bool __p_bExpand, const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_HandLEnable(__p_bSwing, __p_bExpand, &__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_HandLEnable(bool __p_bSwing, bool __p_bExpand, const ::Robot::Callback_Motor_HandLEnablePtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_HandLEnable(__p_bSwing, __p_bExpand, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_HandLEnable(bool __p_bSwing, bool __p_bExpand, const ::Ice::Context& __ctx, const ::Robot::Callback_Motor_HandLEnablePtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_HandLEnable(__p_bSwing, __p_bExpand, &__ctx, __del, __cookie);
    }

    void end_HandLEnable(const ::Ice::AsyncResultPtr&);

private:

    void HandLEnable(bool, bool, const ::Ice::Context*);
    ::Ice::AsyncResultPtr begin_HandLEnable(bool, bool, const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);

public:

    void HandLSwingInit()
    {
        HandLSwingInit(0);
    }
    void HandLSwingInit(const ::Ice::Context& __ctx)
    {
        HandLSwingInit(&__ctx);
    }
#ifdef ICE_CPP11
    ::Ice::AsyncResultPtr
    begin_HandLSwingInit(const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_HandLSwingInit(0, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent));
    }
    ::Ice::AsyncResultPtr
    begin_HandLSwingInit(const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_HandLSwingInit(0, ::Ice::newCallback(__completed, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_HandLSwingInit(const ::Ice::Context& __ctx, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_HandLSwingInit(&__ctx, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_HandLSwingInit(const ::Ice::Context& __ctx, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_HandLSwingInit(&__ctx, ::Ice::newCallback(__completed, __sent));
    }
#endif

    ::Ice::AsyncResultPtr begin_HandLSwingInit()
    {
        return begin_HandLSwingInit(0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_HandLSwingInit(const ::Ice::Context& __ctx)
    {
        return begin_HandLSwingInit(&__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_HandLSwingInit(const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_HandLSwingInit(0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_HandLSwingInit(const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_HandLSwingInit(&__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_HandLSwingInit(const ::Robot::Callback_Motor_HandLSwingInitPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_HandLSwingInit(0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_HandLSwingInit(const ::Ice::Context& __ctx, const ::Robot::Callback_Motor_HandLSwingInitPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_HandLSwingInit(&__ctx, __del, __cookie);
    }

    void end_HandLSwingInit(const ::Ice::AsyncResultPtr&);

private:

    void HandLSwingInit(const ::Ice::Context*);
    ::Ice::AsyncResultPtr begin_HandLSwingInit(const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);

public:

    void HandLExpandInit()
    {
        HandLExpandInit(0);
    }
    void HandLExpandInit(const ::Ice::Context& __ctx)
    {
        HandLExpandInit(&__ctx);
    }
#ifdef ICE_CPP11
    ::Ice::AsyncResultPtr
    begin_HandLExpandInit(const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_HandLExpandInit(0, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent));
    }
    ::Ice::AsyncResultPtr
    begin_HandLExpandInit(const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_HandLExpandInit(0, ::Ice::newCallback(__completed, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_HandLExpandInit(const ::Ice::Context& __ctx, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_HandLExpandInit(&__ctx, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_HandLExpandInit(const ::Ice::Context& __ctx, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_HandLExpandInit(&__ctx, ::Ice::newCallback(__completed, __sent));
    }
#endif

    ::Ice::AsyncResultPtr begin_HandLExpandInit()
    {
        return begin_HandLExpandInit(0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_HandLExpandInit(const ::Ice::Context& __ctx)
    {
        return begin_HandLExpandInit(&__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_HandLExpandInit(const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_HandLExpandInit(0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_HandLExpandInit(const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_HandLExpandInit(&__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_HandLExpandInit(const ::Robot::Callback_Motor_HandLExpandInitPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_HandLExpandInit(0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_HandLExpandInit(const ::Ice::Context& __ctx, const ::Robot::Callback_Motor_HandLExpandInitPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_HandLExpandInit(&__ctx, __del, __cookie);
    }

    void end_HandLExpandInit(const ::Ice::AsyncResultPtr&);

private:

    void HandLExpandInit(const ::Ice::Context*);
    ::Ice::AsyncResultPtr begin_HandLExpandInit(const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);

public:

    void HandLSwingAngle(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed)
    {
        HandLSwingAngle(__p_nAngle, __p_nSpeed, 0);
    }
    void HandLSwingAngle(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed, const ::Ice::Context& __ctx)
    {
        HandLSwingAngle(__p_nAngle, __p_nSpeed, &__ctx);
    }
#ifdef ICE_CPP11
    ::Ice::AsyncResultPtr
    begin_HandLSwingAngle(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_HandLSwingAngle(__p_nAngle, __p_nSpeed, 0, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent));
    }
    ::Ice::AsyncResultPtr
    begin_HandLSwingAngle(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_HandLSwingAngle(__p_nAngle, __p_nSpeed, 0, ::Ice::newCallback(__completed, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_HandLSwingAngle(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed, const ::Ice::Context& __ctx, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_HandLSwingAngle(__p_nAngle, __p_nSpeed, &__ctx, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_HandLSwingAngle(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed, const ::Ice::Context& __ctx, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_HandLSwingAngle(__p_nAngle, __p_nSpeed, &__ctx, ::Ice::newCallback(__completed, __sent));
    }
#endif

    ::Ice::AsyncResultPtr begin_HandLSwingAngle(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed)
    {
        return begin_HandLSwingAngle(__p_nAngle, __p_nSpeed, 0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_HandLSwingAngle(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed, const ::Ice::Context& __ctx)
    {
        return begin_HandLSwingAngle(__p_nAngle, __p_nSpeed, &__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_HandLSwingAngle(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_HandLSwingAngle(__p_nAngle, __p_nSpeed, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_HandLSwingAngle(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed, const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_HandLSwingAngle(__p_nAngle, __p_nSpeed, &__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_HandLSwingAngle(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed, const ::Robot::Callback_Motor_HandLSwingAnglePtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_HandLSwingAngle(__p_nAngle, __p_nSpeed, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_HandLSwingAngle(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed, const ::Ice::Context& __ctx, const ::Robot::Callback_Motor_HandLSwingAnglePtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_HandLSwingAngle(__p_nAngle, __p_nSpeed, &__ctx, __del, __cookie);
    }

    void end_HandLSwingAngle(const ::Ice::AsyncResultPtr&);

private:

    void HandLSwingAngle(::Ice::Int, ::Ice::Int, const ::Ice::Context*);
    ::Ice::AsyncResultPtr begin_HandLSwingAngle(::Ice::Int, ::Ice::Int, const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);

public:

    void HandLExpandAngle(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed)
    {
        HandLExpandAngle(__p_nAngle, __p_nSpeed, 0);
    }
    void HandLExpandAngle(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed, const ::Ice::Context& __ctx)
    {
        HandLExpandAngle(__p_nAngle, __p_nSpeed, &__ctx);
    }
#ifdef ICE_CPP11
    ::Ice::AsyncResultPtr
    begin_HandLExpandAngle(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_HandLExpandAngle(__p_nAngle, __p_nSpeed, 0, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent));
    }
    ::Ice::AsyncResultPtr
    begin_HandLExpandAngle(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_HandLExpandAngle(__p_nAngle, __p_nSpeed, 0, ::Ice::newCallback(__completed, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_HandLExpandAngle(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed, const ::Ice::Context& __ctx, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_HandLExpandAngle(__p_nAngle, __p_nSpeed, &__ctx, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_HandLExpandAngle(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed, const ::Ice::Context& __ctx, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_HandLExpandAngle(__p_nAngle, __p_nSpeed, &__ctx, ::Ice::newCallback(__completed, __sent));
    }
#endif

    ::Ice::AsyncResultPtr begin_HandLExpandAngle(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed)
    {
        return begin_HandLExpandAngle(__p_nAngle, __p_nSpeed, 0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_HandLExpandAngle(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed, const ::Ice::Context& __ctx)
    {
        return begin_HandLExpandAngle(__p_nAngle, __p_nSpeed, &__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_HandLExpandAngle(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_HandLExpandAngle(__p_nAngle, __p_nSpeed, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_HandLExpandAngle(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed, const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_HandLExpandAngle(__p_nAngle, __p_nSpeed, &__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_HandLExpandAngle(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed, const ::Robot::Callback_Motor_HandLExpandAnglePtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_HandLExpandAngle(__p_nAngle, __p_nSpeed, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_HandLExpandAngle(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed, const ::Ice::Context& __ctx, const ::Robot::Callback_Motor_HandLExpandAnglePtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_HandLExpandAngle(__p_nAngle, __p_nSpeed, &__ctx, __del, __cookie);
    }

    void end_HandLExpandAngle(const ::Ice::AsyncResultPtr&);

private:

    void HandLExpandAngle(::Ice::Int, ::Ice::Int, const ::Ice::Context*);
    ::Ice::AsyncResultPtr begin_HandLExpandAngle(::Ice::Int, ::Ice::Int, const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);

public:

    void HandREnable(bool __p_bSwing, bool __p_bExpand)
    {
        HandREnable(__p_bSwing, __p_bExpand, 0);
    }
    void HandREnable(bool __p_bSwing, bool __p_bExpand, const ::Ice::Context& __ctx)
    {
        HandREnable(__p_bSwing, __p_bExpand, &__ctx);
    }
#ifdef ICE_CPP11
    ::Ice::AsyncResultPtr
    begin_HandREnable(bool __p_bSwing, bool __p_bExpand, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_HandREnable(__p_bSwing, __p_bExpand, 0, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent));
    }
    ::Ice::AsyncResultPtr
    begin_HandREnable(bool __p_bSwing, bool __p_bExpand, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_HandREnable(__p_bSwing, __p_bExpand, 0, ::Ice::newCallback(__completed, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_HandREnable(bool __p_bSwing, bool __p_bExpand, const ::Ice::Context& __ctx, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_HandREnable(__p_bSwing, __p_bExpand, &__ctx, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_HandREnable(bool __p_bSwing, bool __p_bExpand, const ::Ice::Context& __ctx, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_HandREnable(__p_bSwing, __p_bExpand, &__ctx, ::Ice::newCallback(__completed, __sent));
    }
#endif

    ::Ice::AsyncResultPtr begin_HandREnable(bool __p_bSwing, bool __p_bExpand)
    {
        return begin_HandREnable(__p_bSwing, __p_bExpand, 0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_HandREnable(bool __p_bSwing, bool __p_bExpand, const ::Ice::Context& __ctx)
    {
        return begin_HandREnable(__p_bSwing, __p_bExpand, &__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_HandREnable(bool __p_bSwing, bool __p_bExpand, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_HandREnable(__p_bSwing, __p_bExpand, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_HandREnable(bool __p_bSwing, bool __p_bExpand, const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_HandREnable(__p_bSwing, __p_bExpand, &__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_HandREnable(bool __p_bSwing, bool __p_bExpand, const ::Robot::Callback_Motor_HandREnablePtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_HandREnable(__p_bSwing, __p_bExpand, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_HandREnable(bool __p_bSwing, bool __p_bExpand, const ::Ice::Context& __ctx, const ::Robot::Callback_Motor_HandREnablePtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_HandREnable(__p_bSwing, __p_bExpand, &__ctx, __del, __cookie);
    }

    void end_HandREnable(const ::Ice::AsyncResultPtr&);

private:

    void HandREnable(bool, bool, const ::Ice::Context*);
    ::Ice::AsyncResultPtr begin_HandREnable(bool, bool, const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);

public:

    void HandRSwingInit()
    {
        HandRSwingInit(0);
    }
    void HandRSwingInit(const ::Ice::Context& __ctx)
    {
        HandRSwingInit(&__ctx);
    }
#ifdef ICE_CPP11
    ::Ice::AsyncResultPtr
    begin_HandRSwingInit(const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_HandRSwingInit(0, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent));
    }
    ::Ice::AsyncResultPtr
    begin_HandRSwingInit(const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_HandRSwingInit(0, ::Ice::newCallback(__completed, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_HandRSwingInit(const ::Ice::Context& __ctx, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_HandRSwingInit(&__ctx, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_HandRSwingInit(const ::Ice::Context& __ctx, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_HandRSwingInit(&__ctx, ::Ice::newCallback(__completed, __sent));
    }
#endif

    ::Ice::AsyncResultPtr begin_HandRSwingInit()
    {
        return begin_HandRSwingInit(0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_HandRSwingInit(const ::Ice::Context& __ctx)
    {
        return begin_HandRSwingInit(&__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_HandRSwingInit(const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_HandRSwingInit(0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_HandRSwingInit(const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_HandRSwingInit(&__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_HandRSwingInit(const ::Robot::Callback_Motor_HandRSwingInitPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_HandRSwingInit(0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_HandRSwingInit(const ::Ice::Context& __ctx, const ::Robot::Callback_Motor_HandRSwingInitPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_HandRSwingInit(&__ctx, __del, __cookie);
    }

    void end_HandRSwingInit(const ::Ice::AsyncResultPtr&);

private:

    void HandRSwingInit(const ::Ice::Context*);
    ::Ice::AsyncResultPtr begin_HandRSwingInit(const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);

public:

    void HandRExpandInit()
    {
        HandRExpandInit(0);
    }
    void HandRExpandInit(const ::Ice::Context& __ctx)
    {
        HandRExpandInit(&__ctx);
    }
#ifdef ICE_CPP11
    ::Ice::AsyncResultPtr
    begin_HandRExpandInit(const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_HandRExpandInit(0, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent));
    }
    ::Ice::AsyncResultPtr
    begin_HandRExpandInit(const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_HandRExpandInit(0, ::Ice::newCallback(__completed, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_HandRExpandInit(const ::Ice::Context& __ctx, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_HandRExpandInit(&__ctx, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_HandRExpandInit(const ::Ice::Context& __ctx, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_HandRExpandInit(&__ctx, ::Ice::newCallback(__completed, __sent));
    }
#endif

    ::Ice::AsyncResultPtr begin_HandRExpandInit()
    {
        return begin_HandRExpandInit(0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_HandRExpandInit(const ::Ice::Context& __ctx)
    {
        return begin_HandRExpandInit(&__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_HandRExpandInit(const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_HandRExpandInit(0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_HandRExpandInit(const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_HandRExpandInit(&__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_HandRExpandInit(const ::Robot::Callback_Motor_HandRExpandInitPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_HandRExpandInit(0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_HandRExpandInit(const ::Ice::Context& __ctx, const ::Robot::Callback_Motor_HandRExpandInitPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_HandRExpandInit(&__ctx, __del, __cookie);
    }

    void end_HandRExpandInit(const ::Ice::AsyncResultPtr&);

private:

    void HandRExpandInit(const ::Ice::Context*);
    ::Ice::AsyncResultPtr begin_HandRExpandInit(const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);

public:

    void HandRSwingAngle(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed)
    {
        HandRSwingAngle(__p_nAngle, __p_nSpeed, 0);
    }
    void HandRSwingAngle(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed, const ::Ice::Context& __ctx)
    {
        HandRSwingAngle(__p_nAngle, __p_nSpeed, &__ctx);
    }
#ifdef ICE_CPP11
    ::Ice::AsyncResultPtr
    begin_HandRSwingAngle(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_HandRSwingAngle(__p_nAngle, __p_nSpeed, 0, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent));
    }
    ::Ice::AsyncResultPtr
    begin_HandRSwingAngle(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_HandRSwingAngle(__p_nAngle, __p_nSpeed, 0, ::Ice::newCallback(__completed, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_HandRSwingAngle(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed, const ::Ice::Context& __ctx, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_HandRSwingAngle(__p_nAngle, __p_nSpeed, &__ctx, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_HandRSwingAngle(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed, const ::Ice::Context& __ctx, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_HandRSwingAngle(__p_nAngle, __p_nSpeed, &__ctx, ::Ice::newCallback(__completed, __sent));
    }
#endif

    ::Ice::AsyncResultPtr begin_HandRSwingAngle(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed)
    {
        return begin_HandRSwingAngle(__p_nAngle, __p_nSpeed, 0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_HandRSwingAngle(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed, const ::Ice::Context& __ctx)
    {
        return begin_HandRSwingAngle(__p_nAngle, __p_nSpeed, &__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_HandRSwingAngle(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_HandRSwingAngle(__p_nAngle, __p_nSpeed, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_HandRSwingAngle(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed, const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_HandRSwingAngle(__p_nAngle, __p_nSpeed, &__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_HandRSwingAngle(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed, const ::Robot::Callback_Motor_HandRSwingAnglePtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_HandRSwingAngle(__p_nAngle, __p_nSpeed, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_HandRSwingAngle(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed, const ::Ice::Context& __ctx, const ::Robot::Callback_Motor_HandRSwingAnglePtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_HandRSwingAngle(__p_nAngle, __p_nSpeed, &__ctx, __del, __cookie);
    }

    void end_HandRSwingAngle(const ::Ice::AsyncResultPtr&);

private:

    void HandRSwingAngle(::Ice::Int, ::Ice::Int, const ::Ice::Context*);
    ::Ice::AsyncResultPtr begin_HandRSwingAngle(::Ice::Int, ::Ice::Int, const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);

public:

    void HandRExpandAngle(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed)
    {
        HandRExpandAngle(__p_nAngle, __p_nSpeed, 0);
    }
    void HandRExpandAngle(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed, const ::Ice::Context& __ctx)
    {
        HandRExpandAngle(__p_nAngle, __p_nSpeed, &__ctx);
    }
#ifdef ICE_CPP11
    ::Ice::AsyncResultPtr
    begin_HandRExpandAngle(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_HandRExpandAngle(__p_nAngle, __p_nSpeed, 0, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent));
    }
    ::Ice::AsyncResultPtr
    begin_HandRExpandAngle(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_HandRExpandAngle(__p_nAngle, __p_nSpeed, 0, ::Ice::newCallback(__completed, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_HandRExpandAngle(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed, const ::Ice::Context& __ctx, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_HandRExpandAngle(__p_nAngle, __p_nSpeed, &__ctx, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_HandRExpandAngle(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed, const ::Ice::Context& __ctx, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_HandRExpandAngle(__p_nAngle, __p_nSpeed, &__ctx, ::Ice::newCallback(__completed, __sent));
    }
#endif

    ::Ice::AsyncResultPtr begin_HandRExpandAngle(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed)
    {
        return begin_HandRExpandAngle(__p_nAngle, __p_nSpeed, 0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_HandRExpandAngle(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed, const ::Ice::Context& __ctx)
    {
        return begin_HandRExpandAngle(__p_nAngle, __p_nSpeed, &__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_HandRExpandAngle(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_HandRExpandAngle(__p_nAngle, __p_nSpeed, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_HandRExpandAngle(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed, const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_HandRExpandAngle(__p_nAngle, __p_nSpeed, &__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_HandRExpandAngle(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed, const ::Robot::Callback_Motor_HandRExpandAnglePtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_HandRExpandAngle(__p_nAngle, __p_nSpeed, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_HandRExpandAngle(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed, const ::Ice::Context& __ctx, const ::Robot::Callback_Motor_HandRExpandAnglePtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_HandRExpandAngle(__p_nAngle, __p_nSpeed, &__ctx, __del, __cookie);
    }

    void end_HandRExpandAngle(const ::Ice::AsyncResultPtr&);

private:

    void HandRExpandAngle(::Ice::Int, ::Ice::Int, const ::Ice::Context*);
    ::Ice::AsyncResultPtr begin_HandRExpandAngle(::Ice::Int, ::Ice::Int, const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);

public:

    void WheelEnable(bool __p_bEnable)
    {
        WheelEnable(__p_bEnable, 0);
    }
    void WheelEnable(bool __p_bEnable, const ::Ice::Context& __ctx)
    {
        WheelEnable(__p_bEnable, &__ctx);
    }
#ifdef ICE_CPP11
    ::Ice::AsyncResultPtr
    begin_WheelEnable(bool __p_bEnable, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_WheelEnable(__p_bEnable, 0, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent));
    }
    ::Ice::AsyncResultPtr
    begin_WheelEnable(bool __p_bEnable, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_WheelEnable(__p_bEnable, 0, ::Ice::newCallback(__completed, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_WheelEnable(bool __p_bEnable, const ::Ice::Context& __ctx, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_WheelEnable(__p_bEnable, &__ctx, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_WheelEnable(bool __p_bEnable, const ::Ice::Context& __ctx, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_WheelEnable(__p_bEnable, &__ctx, ::Ice::newCallback(__completed, __sent));
    }
#endif

    ::Ice::AsyncResultPtr begin_WheelEnable(bool __p_bEnable)
    {
        return begin_WheelEnable(__p_bEnable, 0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_WheelEnable(bool __p_bEnable, const ::Ice::Context& __ctx)
    {
        return begin_WheelEnable(__p_bEnable, &__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_WheelEnable(bool __p_bEnable, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_WheelEnable(__p_bEnable, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_WheelEnable(bool __p_bEnable, const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_WheelEnable(__p_bEnable, &__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_WheelEnable(bool __p_bEnable, const ::Robot::Callback_Motor_WheelEnablePtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_WheelEnable(__p_bEnable, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_WheelEnable(bool __p_bEnable, const ::Ice::Context& __ctx, const ::Robot::Callback_Motor_WheelEnablePtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_WheelEnable(__p_bEnable, &__ctx, __del, __cookie);
    }

    void end_WheelEnable(const ::Ice::AsyncResultPtr&);

private:

    void WheelEnable(bool, const ::Ice::Context*);
    ::Ice::AsyncResultPtr begin_WheelEnable(bool, const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);

public:

    void WheelStop(bool __p_bSlow)
    {
        WheelStop(__p_bSlow, 0);
    }
    void WheelStop(bool __p_bSlow, const ::Ice::Context& __ctx)
    {
        WheelStop(__p_bSlow, &__ctx);
    }
#ifdef ICE_CPP11
    ::Ice::AsyncResultPtr
    begin_WheelStop(bool __p_bSlow, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_WheelStop(__p_bSlow, 0, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent));
    }
    ::Ice::AsyncResultPtr
    begin_WheelStop(bool __p_bSlow, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_WheelStop(__p_bSlow, 0, ::Ice::newCallback(__completed, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_WheelStop(bool __p_bSlow, const ::Ice::Context& __ctx, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_WheelStop(__p_bSlow, &__ctx, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_WheelStop(bool __p_bSlow, const ::Ice::Context& __ctx, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_WheelStop(__p_bSlow, &__ctx, ::Ice::newCallback(__completed, __sent));
    }
#endif

    ::Ice::AsyncResultPtr begin_WheelStop(bool __p_bSlow)
    {
        return begin_WheelStop(__p_bSlow, 0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_WheelStop(bool __p_bSlow, const ::Ice::Context& __ctx)
    {
        return begin_WheelStop(__p_bSlow, &__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_WheelStop(bool __p_bSlow, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_WheelStop(__p_bSlow, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_WheelStop(bool __p_bSlow, const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_WheelStop(__p_bSlow, &__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_WheelStop(bool __p_bSlow, const ::Robot::Callback_Motor_WheelStopPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_WheelStop(__p_bSlow, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_WheelStop(bool __p_bSlow, const ::Ice::Context& __ctx, const ::Robot::Callback_Motor_WheelStopPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_WheelStop(__p_bSlow, &__ctx, __del, __cookie);
    }

    void end_WheelStop(const ::Ice::AsyncResultPtr&);

private:

    void WheelStop(bool, const ::Ice::Context*);
    ::Ice::AsyncResultPtr begin_WheelStop(bool, const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);

public:

    void WheelRotate(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed)
    {
        WheelRotate(__p_nAngle, __p_nSpeed, 0);
    }
    void WheelRotate(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed, const ::Ice::Context& __ctx)
    {
        WheelRotate(__p_nAngle, __p_nSpeed, &__ctx);
    }
#ifdef ICE_CPP11
    ::Ice::AsyncResultPtr
    begin_WheelRotate(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_WheelRotate(__p_nAngle, __p_nSpeed, 0, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent));
    }
    ::Ice::AsyncResultPtr
    begin_WheelRotate(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_WheelRotate(__p_nAngle, __p_nSpeed, 0, ::Ice::newCallback(__completed, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_WheelRotate(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed, const ::Ice::Context& __ctx, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_WheelRotate(__p_nAngle, __p_nSpeed, &__ctx, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_WheelRotate(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed, const ::Ice::Context& __ctx, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_WheelRotate(__p_nAngle, __p_nSpeed, &__ctx, ::Ice::newCallback(__completed, __sent));
    }
#endif

    ::Ice::AsyncResultPtr begin_WheelRotate(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed)
    {
        return begin_WheelRotate(__p_nAngle, __p_nSpeed, 0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_WheelRotate(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed, const ::Ice::Context& __ctx)
    {
        return begin_WheelRotate(__p_nAngle, __p_nSpeed, &__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_WheelRotate(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_WheelRotate(__p_nAngle, __p_nSpeed, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_WheelRotate(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed, const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_WheelRotate(__p_nAngle, __p_nSpeed, &__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_WheelRotate(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed, const ::Robot::Callback_Motor_WheelRotatePtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_WheelRotate(__p_nAngle, __p_nSpeed, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_WheelRotate(::Ice::Int __p_nAngle, ::Ice::Int __p_nSpeed, const ::Ice::Context& __ctx, const ::Robot::Callback_Motor_WheelRotatePtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_WheelRotate(__p_nAngle, __p_nSpeed, &__ctx, __del, __cookie);
    }

    void end_WheelRotate(const ::Ice::AsyncResultPtr&);

private:

    void WheelRotate(::Ice::Int, ::Ice::Int, const ::Ice::Context*);
    ::Ice::AsyncResultPtr begin_WheelRotate(::Ice::Int, ::Ice::Int, const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);

public:

    void WheelRun(::Ice::Int __p_nDistance, ::Ice::Int __p_nSpeed)
    {
        WheelRun(__p_nDistance, __p_nSpeed, 0);
    }
    void WheelRun(::Ice::Int __p_nDistance, ::Ice::Int __p_nSpeed, const ::Ice::Context& __ctx)
    {
        WheelRun(__p_nDistance, __p_nSpeed, &__ctx);
    }
#ifdef ICE_CPP11
    ::Ice::AsyncResultPtr
    begin_WheelRun(::Ice::Int __p_nDistance, ::Ice::Int __p_nSpeed, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_WheelRun(__p_nDistance, __p_nSpeed, 0, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent));
    }
    ::Ice::AsyncResultPtr
    begin_WheelRun(::Ice::Int __p_nDistance, ::Ice::Int __p_nSpeed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_WheelRun(__p_nDistance, __p_nSpeed, 0, ::Ice::newCallback(__completed, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_WheelRun(::Ice::Int __p_nDistance, ::Ice::Int __p_nSpeed, const ::Ice::Context& __ctx, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_WheelRun(__p_nDistance, __p_nSpeed, &__ctx, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_WheelRun(::Ice::Int __p_nDistance, ::Ice::Int __p_nSpeed, const ::Ice::Context& __ctx, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_WheelRun(__p_nDistance, __p_nSpeed, &__ctx, ::Ice::newCallback(__completed, __sent));
    }
#endif

    ::Ice::AsyncResultPtr begin_WheelRun(::Ice::Int __p_nDistance, ::Ice::Int __p_nSpeed)
    {
        return begin_WheelRun(__p_nDistance, __p_nSpeed, 0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_WheelRun(::Ice::Int __p_nDistance, ::Ice::Int __p_nSpeed, const ::Ice::Context& __ctx)
    {
        return begin_WheelRun(__p_nDistance, __p_nSpeed, &__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_WheelRun(::Ice::Int __p_nDistance, ::Ice::Int __p_nSpeed, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_WheelRun(__p_nDistance, __p_nSpeed, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_WheelRun(::Ice::Int __p_nDistance, ::Ice::Int __p_nSpeed, const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_WheelRun(__p_nDistance, __p_nSpeed, &__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_WheelRun(::Ice::Int __p_nDistance, ::Ice::Int __p_nSpeed, const ::Robot::Callback_Motor_WheelRunPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_WheelRun(__p_nDistance, __p_nSpeed, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_WheelRun(::Ice::Int __p_nDistance, ::Ice::Int __p_nSpeed, const ::Ice::Context& __ctx, const ::Robot::Callback_Motor_WheelRunPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_WheelRun(__p_nDistance, __p_nSpeed, &__ctx, __del, __cookie);
    }

    void end_WheelRun(const ::Ice::AsyncResultPtr&);

private:

    void WheelRun(::Ice::Int, ::Ice::Int, const ::Ice::Context*);
    ::Ice::AsyncResultPtr begin_WheelRun(::Ice::Int, ::Ice::Int, const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);

public:

    void WheelRunDiff(bool __p_bLeftUP, ::Ice::Int __p_nLeftSpeed, bool __p_bRight, ::Ice::Int __p_nRightSpeed)
    {
        WheelRunDiff(__p_bLeftUP, __p_nLeftSpeed, __p_bRight, __p_nRightSpeed, 0);
    }
    void WheelRunDiff(bool __p_bLeftUP, ::Ice::Int __p_nLeftSpeed, bool __p_bRight, ::Ice::Int __p_nRightSpeed, const ::Ice::Context& __ctx)
    {
        WheelRunDiff(__p_bLeftUP, __p_nLeftSpeed, __p_bRight, __p_nRightSpeed, &__ctx);
    }
#ifdef ICE_CPP11
    ::Ice::AsyncResultPtr
    begin_WheelRunDiff(bool __p_bLeftUP, ::Ice::Int __p_nLeftSpeed, bool __p_bRight, ::Ice::Int __p_nRightSpeed, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_WheelRunDiff(__p_bLeftUP, __p_nLeftSpeed, __p_bRight, __p_nRightSpeed, 0, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent));
    }
    ::Ice::AsyncResultPtr
    begin_WheelRunDiff(bool __p_bLeftUP, ::Ice::Int __p_nLeftSpeed, bool __p_bRight, ::Ice::Int __p_nRightSpeed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_WheelRunDiff(__p_bLeftUP, __p_nLeftSpeed, __p_bRight, __p_nRightSpeed, 0, ::Ice::newCallback(__completed, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_WheelRunDiff(bool __p_bLeftUP, ::Ice::Int __p_nLeftSpeed, bool __p_bRight, ::Ice::Int __p_nRightSpeed, const ::Ice::Context& __ctx, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_WheelRunDiff(__p_bLeftUP, __p_nLeftSpeed, __p_bRight, __p_nRightSpeed, &__ctx, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_WheelRunDiff(bool __p_bLeftUP, ::Ice::Int __p_nLeftSpeed, bool __p_bRight, ::Ice::Int __p_nRightSpeed, const ::Ice::Context& __ctx, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_WheelRunDiff(__p_bLeftUP, __p_nLeftSpeed, __p_bRight, __p_nRightSpeed, &__ctx, ::Ice::newCallback(__completed, __sent));
    }
#endif

    ::Ice::AsyncResultPtr begin_WheelRunDiff(bool __p_bLeftUP, ::Ice::Int __p_nLeftSpeed, bool __p_bRight, ::Ice::Int __p_nRightSpeed)
    {
        return begin_WheelRunDiff(__p_bLeftUP, __p_nLeftSpeed, __p_bRight, __p_nRightSpeed, 0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_WheelRunDiff(bool __p_bLeftUP, ::Ice::Int __p_nLeftSpeed, bool __p_bRight, ::Ice::Int __p_nRightSpeed, const ::Ice::Context& __ctx)
    {
        return begin_WheelRunDiff(__p_bLeftUP, __p_nLeftSpeed, __p_bRight, __p_nRightSpeed, &__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_WheelRunDiff(bool __p_bLeftUP, ::Ice::Int __p_nLeftSpeed, bool __p_bRight, ::Ice::Int __p_nRightSpeed, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_WheelRunDiff(__p_bLeftUP, __p_nLeftSpeed, __p_bRight, __p_nRightSpeed, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_WheelRunDiff(bool __p_bLeftUP, ::Ice::Int __p_nLeftSpeed, bool __p_bRight, ::Ice::Int __p_nRightSpeed, const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_WheelRunDiff(__p_bLeftUP, __p_nLeftSpeed, __p_bRight, __p_nRightSpeed, &__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_WheelRunDiff(bool __p_bLeftUP, ::Ice::Int __p_nLeftSpeed, bool __p_bRight, ::Ice::Int __p_nRightSpeed, const ::Robot::Callback_Motor_WheelRunDiffPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_WheelRunDiff(__p_bLeftUP, __p_nLeftSpeed, __p_bRight, __p_nRightSpeed, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_WheelRunDiff(bool __p_bLeftUP, ::Ice::Int __p_nLeftSpeed, bool __p_bRight, ::Ice::Int __p_nRightSpeed, const ::Ice::Context& __ctx, const ::Robot::Callback_Motor_WheelRunDiffPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_WheelRunDiff(__p_bLeftUP, __p_nLeftSpeed, __p_bRight, __p_nRightSpeed, &__ctx, __del, __cookie);
    }

    void end_WheelRunDiff(const ::Ice::AsyncResultPtr&);

private:

    void WheelRunDiff(bool, ::Ice::Int, bool, ::Ice::Int, const ::Ice::Context*);
    ::Ice::AsyncResultPtr begin_WheelRunDiff(bool, ::Ice::Int, bool, ::Ice::Int, const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);

public:

    void HeadEye(::Ice::Int __p_nIndexF, ::Ice::Int __p_nIndexB)
    {
        HeadEye(__p_nIndexF, __p_nIndexB, 0);
    }
    void HeadEye(::Ice::Int __p_nIndexF, ::Ice::Int __p_nIndexB, const ::Ice::Context& __ctx)
    {
        HeadEye(__p_nIndexF, __p_nIndexB, &__ctx);
    }
#ifdef ICE_CPP11
    ::Ice::AsyncResultPtr
    begin_HeadEye(::Ice::Int __p_nIndexF, ::Ice::Int __p_nIndexB, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_HeadEye(__p_nIndexF, __p_nIndexB, 0, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent));
    }
    ::Ice::AsyncResultPtr
    begin_HeadEye(::Ice::Int __p_nIndexF, ::Ice::Int __p_nIndexB, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_HeadEye(__p_nIndexF, __p_nIndexB, 0, ::Ice::newCallback(__completed, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_HeadEye(::Ice::Int __p_nIndexF, ::Ice::Int __p_nIndexB, const ::Ice::Context& __ctx, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_HeadEye(__p_nIndexF, __p_nIndexB, &__ctx, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_HeadEye(::Ice::Int __p_nIndexF, ::Ice::Int __p_nIndexB, const ::Ice::Context& __ctx, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_HeadEye(__p_nIndexF, __p_nIndexB, &__ctx, ::Ice::newCallback(__completed, __sent));
    }
#endif

    ::Ice::AsyncResultPtr begin_HeadEye(::Ice::Int __p_nIndexF, ::Ice::Int __p_nIndexB)
    {
        return begin_HeadEye(__p_nIndexF, __p_nIndexB, 0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_HeadEye(::Ice::Int __p_nIndexF, ::Ice::Int __p_nIndexB, const ::Ice::Context& __ctx)
    {
        return begin_HeadEye(__p_nIndexF, __p_nIndexB, &__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_HeadEye(::Ice::Int __p_nIndexF, ::Ice::Int __p_nIndexB, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_HeadEye(__p_nIndexF, __p_nIndexB, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_HeadEye(::Ice::Int __p_nIndexF, ::Ice::Int __p_nIndexB, const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_HeadEye(__p_nIndexF, __p_nIndexB, &__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_HeadEye(::Ice::Int __p_nIndexF, ::Ice::Int __p_nIndexB, const ::Robot::Callback_Motor_HeadEyePtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_HeadEye(__p_nIndexF, __p_nIndexB, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_HeadEye(::Ice::Int __p_nIndexF, ::Ice::Int __p_nIndexB, const ::Ice::Context& __ctx, const ::Robot::Callback_Motor_HeadEyePtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_HeadEye(__p_nIndexF, __p_nIndexB, &__ctx, __del, __cookie);
    }

    void end_HeadEye(const ::Ice::AsyncResultPtr&);

private:

    void HeadEye(::Ice::Int, ::Ice::Int, const ::Ice::Context*);
    ::Ice::AsyncResultPtr begin_HeadEye(::Ice::Int, ::Ice::Int, const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);

public:

    void HeadEye2(::Ice::Int __p_nDelay, bool __p_bR, bool __p_bG, bool __p_bB)
    {
        HeadEye2(__p_nDelay, __p_bR, __p_bG, __p_bB, 0);
    }
    void HeadEye2(::Ice::Int __p_nDelay, bool __p_bR, bool __p_bG, bool __p_bB, const ::Ice::Context& __ctx)
    {
        HeadEye2(__p_nDelay, __p_bR, __p_bG, __p_bB, &__ctx);
    }
#ifdef ICE_CPP11
    ::Ice::AsyncResultPtr
    begin_HeadEye2(::Ice::Int __p_nDelay, bool __p_bR, bool __p_bG, bool __p_bB, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_HeadEye2(__p_nDelay, __p_bR, __p_bG, __p_bB, 0, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent));
    }
    ::Ice::AsyncResultPtr
    begin_HeadEye2(::Ice::Int __p_nDelay, bool __p_bR, bool __p_bG, bool __p_bB, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_HeadEye2(__p_nDelay, __p_bR, __p_bG, __p_bB, 0, ::Ice::newCallback(__completed, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_HeadEye2(::Ice::Int __p_nDelay, bool __p_bR, bool __p_bG, bool __p_bB, const ::Ice::Context& __ctx, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_HeadEye2(__p_nDelay, __p_bR, __p_bG, __p_bB, &__ctx, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_HeadEye2(::Ice::Int __p_nDelay, bool __p_bR, bool __p_bG, bool __p_bB, const ::Ice::Context& __ctx, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_HeadEye2(__p_nDelay, __p_bR, __p_bG, __p_bB, &__ctx, ::Ice::newCallback(__completed, __sent));
    }
#endif

    ::Ice::AsyncResultPtr begin_HeadEye2(::Ice::Int __p_nDelay, bool __p_bR, bool __p_bG, bool __p_bB)
    {
        return begin_HeadEye2(__p_nDelay, __p_bR, __p_bG, __p_bB, 0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_HeadEye2(::Ice::Int __p_nDelay, bool __p_bR, bool __p_bG, bool __p_bB, const ::Ice::Context& __ctx)
    {
        return begin_HeadEye2(__p_nDelay, __p_bR, __p_bG, __p_bB, &__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_HeadEye2(::Ice::Int __p_nDelay, bool __p_bR, bool __p_bG, bool __p_bB, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_HeadEye2(__p_nDelay, __p_bR, __p_bG, __p_bB, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_HeadEye2(::Ice::Int __p_nDelay, bool __p_bR, bool __p_bG, bool __p_bB, const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_HeadEye2(__p_nDelay, __p_bR, __p_bG, __p_bB, &__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_HeadEye2(::Ice::Int __p_nDelay, bool __p_bR, bool __p_bG, bool __p_bB, const ::Robot::Callback_Motor_HeadEye2Ptr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_HeadEye2(__p_nDelay, __p_bR, __p_bG, __p_bB, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_HeadEye2(::Ice::Int __p_nDelay, bool __p_bR, bool __p_bG, bool __p_bB, const ::Ice::Context& __ctx, const ::Robot::Callback_Motor_HeadEye2Ptr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_HeadEye2(__p_nDelay, __p_bR, __p_bG, __p_bB, &__ctx, __del, __cookie);
    }

    void end_HeadEye2(const ::Ice::AsyncResultPtr&);

private:

    void HeadEye2(::Ice::Int, bool, bool, bool, const ::Ice::Context*);
    ::Ice::AsyncResultPtr begin_HeadEye2(::Ice::Int, bool, bool, bool, const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);

public:

    void HeadEar(::Ice::Int __p_nDelay, bool __p_bR, bool __p_bG, bool __p_bB)
    {
        HeadEar(__p_nDelay, __p_bR, __p_bG, __p_bB, 0);
    }
    void HeadEar(::Ice::Int __p_nDelay, bool __p_bR, bool __p_bG, bool __p_bB, const ::Ice::Context& __ctx)
    {
        HeadEar(__p_nDelay, __p_bR, __p_bG, __p_bB, &__ctx);
    }
#ifdef ICE_CPP11
    ::Ice::AsyncResultPtr
    begin_HeadEar(::Ice::Int __p_nDelay, bool __p_bR, bool __p_bG, bool __p_bB, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_HeadEar(__p_nDelay, __p_bR, __p_bG, __p_bB, 0, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent));
    }
    ::Ice::AsyncResultPtr
    begin_HeadEar(::Ice::Int __p_nDelay, bool __p_bR, bool __p_bG, bool __p_bB, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_HeadEar(__p_nDelay, __p_bR, __p_bG, __p_bB, 0, ::Ice::newCallback(__completed, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_HeadEar(::Ice::Int __p_nDelay, bool __p_bR, bool __p_bG, bool __p_bB, const ::Ice::Context& __ctx, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_HeadEar(__p_nDelay, __p_bR, __p_bG, __p_bB, &__ctx, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_HeadEar(::Ice::Int __p_nDelay, bool __p_bR, bool __p_bG, bool __p_bB, const ::Ice::Context& __ctx, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_HeadEar(__p_nDelay, __p_bR, __p_bG, __p_bB, &__ctx, ::Ice::newCallback(__completed, __sent));
    }
#endif

    ::Ice::AsyncResultPtr begin_HeadEar(::Ice::Int __p_nDelay, bool __p_bR, bool __p_bG, bool __p_bB)
    {
        return begin_HeadEar(__p_nDelay, __p_bR, __p_bG, __p_bB, 0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_HeadEar(::Ice::Int __p_nDelay, bool __p_bR, bool __p_bG, bool __p_bB, const ::Ice::Context& __ctx)
    {
        return begin_HeadEar(__p_nDelay, __p_bR, __p_bG, __p_bB, &__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_HeadEar(::Ice::Int __p_nDelay, bool __p_bR, bool __p_bG, bool __p_bB, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_HeadEar(__p_nDelay, __p_bR, __p_bG, __p_bB, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_HeadEar(::Ice::Int __p_nDelay, bool __p_bR, bool __p_bG, bool __p_bB, const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_HeadEar(__p_nDelay, __p_bR, __p_bG, __p_bB, &__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_HeadEar(::Ice::Int __p_nDelay, bool __p_bR, bool __p_bG, bool __p_bB, const ::Robot::Callback_Motor_HeadEarPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_HeadEar(__p_nDelay, __p_bR, __p_bG, __p_bB, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_HeadEar(::Ice::Int __p_nDelay, bool __p_bR, bool __p_bG, bool __p_bB, const ::Ice::Context& __ctx, const ::Robot::Callback_Motor_HeadEarPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_HeadEar(__p_nDelay, __p_bR, __p_bG, __p_bB, &__ctx, __del, __cookie);
    }

    void end_HeadEar(const ::Ice::AsyncResultPtr&);

private:

    void HeadEar(::Ice::Int, bool, bool, bool, const ::Ice::Context*);
    ::Ice::AsyncResultPtr begin_HeadEar(::Ice::Int, bool, bool, bool, const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);

public:

    void BodyLed(::Ice::Int __p_nDelay, bool __p_bR, bool __p_bG, bool __p_bB)
    {
        BodyLed(__p_nDelay, __p_bR, __p_bG, __p_bB, 0);
    }
    void BodyLed(::Ice::Int __p_nDelay, bool __p_bR, bool __p_bG, bool __p_bB, const ::Ice::Context& __ctx)
    {
        BodyLed(__p_nDelay, __p_bR, __p_bG, __p_bB, &__ctx);
    }
#ifdef ICE_CPP11
    ::Ice::AsyncResultPtr
    begin_BodyLed(::Ice::Int __p_nDelay, bool __p_bR, bool __p_bG, bool __p_bB, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_BodyLed(__p_nDelay, __p_bR, __p_bG, __p_bB, 0, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent));
    }
    ::Ice::AsyncResultPtr
    begin_BodyLed(::Ice::Int __p_nDelay, bool __p_bR, bool __p_bG, bool __p_bB, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_BodyLed(__p_nDelay, __p_bR, __p_bG, __p_bB, 0, ::Ice::newCallback(__completed, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_BodyLed(::Ice::Int __p_nDelay, bool __p_bR, bool __p_bG, bool __p_bB, const ::Ice::Context& __ctx, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_BodyLed(__p_nDelay, __p_bR, __p_bG, __p_bB, &__ctx, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_BodyLed(::Ice::Int __p_nDelay, bool __p_bR, bool __p_bG, bool __p_bB, const ::Ice::Context& __ctx, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_BodyLed(__p_nDelay, __p_bR, __p_bG, __p_bB, &__ctx, ::Ice::newCallback(__completed, __sent));
    }
#endif

    ::Ice::AsyncResultPtr begin_BodyLed(::Ice::Int __p_nDelay, bool __p_bR, bool __p_bG, bool __p_bB)
    {
        return begin_BodyLed(__p_nDelay, __p_bR, __p_bG, __p_bB, 0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_BodyLed(::Ice::Int __p_nDelay, bool __p_bR, bool __p_bG, bool __p_bB, const ::Ice::Context& __ctx)
    {
        return begin_BodyLed(__p_nDelay, __p_bR, __p_bG, __p_bB, &__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_BodyLed(::Ice::Int __p_nDelay, bool __p_bR, bool __p_bG, bool __p_bB, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_BodyLed(__p_nDelay, __p_bR, __p_bG, __p_bB, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_BodyLed(::Ice::Int __p_nDelay, bool __p_bR, bool __p_bG, bool __p_bB, const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_BodyLed(__p_nDelay, __p_bR, __p_bG, __p_bB, &__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_BodyLed(::Ice::Int __p_nDelay, bool __p_bR, bool __p_bG, bool __p_bB, const ::Robot::Callback_Motor_BodyLedPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_BodyLed(__p_nDelay, __p_bR, __p_bG, __p_bB, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_BodyLed(::Ice::Int __p_nDelay, bool __p_bR, bool __p_bG, bool __p_bB, const ::Ice::Context& __ctx, const ::Robot::Callback_Motor_BodyLedPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_BodyLed(__p_nDelay, __p_bR, __p_bG, __p_bB, &__ctx, __del, __cookie);
    }

    void end_BodyLed(const ::Ice::AsyncResultPtr&);

private:

    void BodyLed(::Ice::Int, bool, bool, bool, const ::Ice::Context*);
    ::Ice::AsyncResultPtr begin_BodyLed(::Ice::Int, bool, bool, bool, const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);

public:

    void TouchSet(bool __p_bFlash, ::Ice::Int __p_nColor, ::Ice::Int __p_nDelay)
    {
        TouchSet(__p_bFlash, __p_nColor, __p_nDelay, 0);
    }
    void TouchSet(bool __p_bFlash, ::Ice::Int __p_nColor, ::Ice::Int __p_nDelay, const ::Ice::Context& __ctx)
    {
        TouchSet(__p_bFlash, __p_nColor, __p_nDelay, &__ctx);
    }
#ifdef ICE_CPP11
    ::Ice::AsyncResultPtr
    begin_TouchSet(bool __p_bFlash, ::Ice::Int __p_nColor, ::Ice::Int __p_nDelay, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_TouchSet(__p_bFlash, __p_nColor, __p_nDelay, 0, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent));
    }
    ::Ice::AsyncResultPtr
    begin_TouchSet(bool __p_bFlash, ::Ice::Int __p_nColor, ::Ice::Int __p_nDelay, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_TouchSet(__p_bFlash, __p_nColor, __p_nDelay, 0, ::Ice::newCallback(__completed, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_TouchSet(bool __p_bFlash, ::Ice::Int __p_nColor, ::Ice::Int __p_nDelay, const ::Ice::Context& __ctx, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_TouchSet(__p_bFlash, __p_nColor, __p_nDelay, &__ctx, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_TouchSet(bool __p_bFlash, ::Ice::Int __p_nColor, ::Ice::Int __p_nDelay, const ::Ice::Context& __ctx, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_TouchSet(__p_bFlash, __p_nColor, __p_nDelay, &__ctx, ::Ice::newCallback(__completed, __sent));
    }
#endif

    ::Ice::AsyncResultPtr begin_TouchSet(bool __p_bFlash, ::Ice::Int __p_nColor, ::Ice::Int __p_nDelay)
    {
        return begin_TouchSet(__p_bFlash, __p_nColor, __p_nDelay, 0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_TouchSet(bool __p_bFlash, ::Ice::Int __p_nColor, ::Ice::Int __p_nDelay, const ::Ice::Context& __ctx)
    {
        return begin_TouchSet(__p_bFlash, __p_nColor, __p_nDelay, &__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_TouchSet(bool __p_bFlash, ::Ice::Int __p_nColor, ::Ice::Int __p_nDelay, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_TouchSet(__p_bFlash, __p_nColor, __p_nDelay, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_TouchSet(bool __p_bFlash, ::Ice::Int __p_nColor, ::Ice::Int __p_nDelay, const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_TouchSet(__p_bFlash, __p_nColor, __p_nDelay, &__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_TouchSet(bool __p_bFlash, ::Ice::Int __p_nColor, ::Ice::Int __p_nDelay, const ::Robot::Callback_Motor_TouchSetPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_TouchSet(__p_bFlash, __p_nColor, __p_nDelay, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_TouchSet(bool __p_bFlash, ::Ice::Int __p_nColor, ::Ice::Int __p_nDelay, const ::Ice::Context& __ctx, const ::Robot::Callback_Motor_TouchSetPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_TouchSet(__p_bFlash, __p_nColor, __p_nDelay, &__ctx, __del, __cookie);
    }

    void end_TouchSet(const ::Ice::AsyncResultPtr&);

private:

    void TouchSet(bool, ::Ice::Int, ::Ice::Int, const ::Ice::Context*);
    ::Ice::AsyncResultPtr begin_TouchSet(bool, ::Ice::Int, ::Ice::Int, const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);

public:

    void SensorBatteryValue(::Ice::IntSeq& __p_nValList)
    {
        SensorBatteryValue(__p_nValList, 0);
    }
    void SensorBatteryValue(::Ice::IntSeq& __p_nValList, const ::Ice::Context& __ctx)
    {
        SensorBatteryValue(__p_nValList, &__ctx);
    }
#ifdef ICE_CPP11
    ::Ice::AsyncResultPtr
    begin_SensorBatteryValue(const ::IceInternal::Function<void (const ::Ice::IntSeq&)>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return __begin_SensorBatteryValue(0, __response, __exception, __sent);
    }
    ::Ice::AsyncResultPtr
    begin_SensorBatteryValue(const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_SensorBatteryValue(0, ::Ice::newCallback(__completed, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_SensorBatteryValue(const ::Ice::Context& __ctx, const ::IceInternal::Function<void (const ::Ice::IntSeq&)>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return __begin_SensorBatteryValue(&__ctx, __response, __exception, __sent);
    }
    ::Ice::AsyncResultPtr
    begin_SensorBatteryValue(const ::Ice::Context& __ctx, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_SensorBatteryValue(&__ctx, ::Ice::newCallback(__completed, __sent));
    }

private:

    ::Ice::AsyncResultPtr __begin_SensorBatteryValue(const ::Ice::Context* __ctx, const ::IceInternal::Function<void (const ::Ice::IntSeq&)>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception, const ::IceInternal::Function<void (bool)>& __sent);

public:
#endif

    ::Ice::AsyncResultPtr begin_SensorBatteryValue()
    {
        return begin_SensorBatteryValue(0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_SensorBatteryValue(const ::Ice::Context& __ctx)
    {
        return begin_SensorBatteryValue(&__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_SensorBatteryValue(const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_SensorBatteryValue(0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_SensorBatteryValue(const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_SensorBatteryValue(&__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_SensorBatteryValue(const ::Robot::Callback_Motor_SensorBatteryValuePtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_SensorBatteryValue(0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_SensorBatteryValue(const ::Ice::Context& __ctx, const ::Robot::Callback_Motor_SensorBatteryValuePtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_SensorBatteryValue(&__ctx, __del, __cookie);
    }

    void end_SensorBatteryValue(::Ice::IntSeq& __p_nValList, const ::Ice::AsyncResultPtr&);

private:

    void SensorBatteryValue(::Ice::IntSeq&, const ::Ice::Context*);
    ::Ice::AsyncResultPtr begin_SensorBatteryValue(const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);

public:

    void SensorSonicValue(::Ice::IntSeq& __p_nValList)
    {
        SensorSonicValue(__p_nValList, 0);
    }
    void SensorSonicValue(::Ice::IntSeq& __p_nValList, const ::Ice::Context& __ctx)
    {
        SensorSonicValue(__p_nValList, &__ctx);
    }
#ifdef ICE_CPP11
    ::Ice::AsyncResultPtr
    begin_SensorSonicValue(const ::IceInternal::Function<void (const ::Ice::IntSeq&)>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return __begin_SensorSonicValue(0, __response, __exception, __sent);
    }
    ::Ice::AsyncResultPtr
    begin_SensorSonicValue(const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_SensorSonicValue(0, ::Ice::newCallback(__completed, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_SensorSonicValue(const ::Ice::Context& __ctx, const ::IceInternal::Function<void (const ::Ice::IntSeq&)>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return __begin_SensorSonicValue(&__ctx, __response, __exception, __sent);
    }
    ::Ice::AsyncResultPtr
    begin_SensorSonicValue(const ::Ice::Context& __ctx, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_SensorSonicValue(&__ctx, ::Ice::newCallback(__completed, __sent));
    }

private:

    ::Ice::AsyncResultPtr __begin_SensorSonicValue(const ::Ice::Context* __ctx, const ::IceInternal::Function<void (const ::Ice::IntSeq&)>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception, const ::IceInternal::Function<void (bool)>& __sent);

public:
#endif

    ::Ice::AsyncResultPtr begin_SensorSonicValue()
    {
        return begin_SensorSonicValue(0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_SensorSonicValue(const ::Ice::Context& __ctx)
    {
        return begin_SensorSonicValue(&__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_SensorSonicValue(const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_SensorSonicValue(0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_SensorSonicValue(const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_SensorSonicValue(&__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_SensorSonicValue(const ::Robot::Callback_Motor_SensorSonicValuePtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_SensorSonicValue(0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_SensorSonicValue(const ::Ice::Context& __ctx, const ::Robot::Callback_Motor_SensorSonicValuePtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_SensorSonicValue(&__ctx, __del, __cookie);
    }

    void end_SensorSonicValue(::Ice::IntSeq& __p_nValList, const ::Ice::AsyncResultPtr&);

private:

    void SensorSonicValue(::Ice::IntSeq&, const ::Ice::Context*);
    ::Ice::AsyncResultPtr begin_SensorSonicValue(const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);

public:

    void SensorInfraredValue(::Ice::IntSeq& __p_nValList)
    {
        SensorInfraredValue(__p_nValList, 0);
    }
    void SensorInfraredValue(::Ice::IntSeq& __p_nValList, const ::Ice::Context& __ctx)
    {
        SensorInfraredValue(__p_nValList, &__ctx);
    }
#ifdef ICE_CPP11
    ::Ice::AsyncResultPtr
    begin_SensorInfraredValue(const ::IceInternal::Function<void (const ::Ice::IntSeq&)>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return __begin_SensorInfraredValue(0, __response, __exception, __sent);
    }
    ::Ice::AsyncResultPtr
    begin_SensorInfraredValue(const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_SensorInfraredValue(0, ::Ice::newCallback(__completed, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_SensorInfraredValue(const ::Ice::Context& __ctx, const ::IceInternal::Function<void (const ::Ice::IntSeq&)>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return __begin_SensorInfraredValue(&__ctx, __response, __exception, __sent);
    }
    ::Ice::AsyncResultPtr
    begin_SensorInfraredValue(const ::Ice::Context& __ctx, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_SensorInfraredValue(&__ctx, ::Ice::newCallback(__completed, __sent));
    }

private:

    ::Ice::AsyncResultPtr __begin_SensorInfraredValue(const ::Ice::Context* __ctx, const ::IceInternal::Function<void (const ::Ice::IntSeq&)>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception, const ::IceInternal::Function<void (bool)>& __sent);

public:
#endif

    ::Ice::AsyncResultPtr begin_SensorInfraredValue()
    {
        return begin_SensorInfraredValue(0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_SensorInfraredValue(const ::Ice::Context& __ctx)
    {
        return begin_SensorInfraredValue(&__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_SensorInfraredValue(const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_SensorInfraredValue(0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_SensorInfraredValue(const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_SensorInfraredValue(&__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_SensorInfraredValue(const ::Robot::Callback_Motor_SensorInfraredValuePtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_SensorInfraredValue(0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_SensorInfraredValue(const ::Ice::Context& __ctx, const ::Robot::Callback_Motor_SensorInfraredValuePtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_SensorInfraredValue(&__ctx, __del, __cookie);
    }

    void end_SensorInfraredValue(::Ice::IntSeq& __p_nValList, const ::Ice::AsyncResultPtr&);

private:

    void SensorInfraredValue(::Ice::IntSeq&, const ::Ice::Context*);
    ::Ice::AsyncResultPtr begin_SensorInfraredValue(const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);

public:

    void SetProtect(bool __p_bOpen)
    {
        SetProtect(__p_bOpen, 0);
    }
    void SetProtect(bool __p_bOpen, const ::Ice::Context& __ctx)
    {
        SetProtect(__p_bOpen, &__ctx);
    }
#ifdef ICE_CPP11
    ::Ice::AsyncResultPtr
    begin_SetProtect(bool __p_bOpen, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_SetProtect(__p_bOpen, 0, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent));
    }
    ::Ice::AsyncResultPtr
    begin_SetProtect(bool __p_bOpen, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_SetProtect(__p_bOpen, 0, ::Ice::newCallback(__completed, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_SetProtect(bool __p_bOpen, const ::Ice::Context& __ctx, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_SetProtect(__p_bOpen, &__ctx, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_SetProtect(bool __p_bOpen, const ::Ice::Context& __ctx, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_SetProtect(__p_bOpen, &__ctx, ::Ice::newCallback(__completed, __sent));
    }
#endif

    ::Ice::AsyncResultPtr begin_SetProtect(bool __p_bOpen)
    {
        return begin_SetProtect(__p_bOpen, 0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_SetProtect(bool __p_bOpen, const ::Ice::Context& __ctx)
    {
        return begin_SetProtect(__p_bOpen, &__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_SetProtect(bool __p_bOpen, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_SetProtect(__p_bOpen, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_SetProtect(bool __p_bOpen, const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_SetProtect(__p_bOpen, &__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_SetProtect(bool __p_bOpen, const ::Robot::Callback_Motor_SetProtectPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_SetProtect(__p_bOpen, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_SetProtect(bool __p_bOpen, const ::Ice::Context& __ctx, const ::Robot::Callback_Motor_SetProtectPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_SetProtect(__p_bOpen, &__ctx, __del, __cookie);
    }

    void end_SetProtect(const ::Ice::AsyncResultPtr&);

private:

    void SetProtect(bool, const ::Ice::Context*);
    ::Ice::AsyncResultPtr begin_SetProtect(bool, const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);

public:

    bool GetProtect()
    {
        return GetProtect(0);
    }
    bool GetProtect(const ::Ice::Context& __ctx)
    {
        return GetProtect(&__ctx);
    }
#ifdef ICE_CPP11
    ::Ice::AsyncResultPtr
    begin_GetProtect(const ::IceInternal::Function<void (bool)>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return __begin_GetProtect(0, __response, __exception, __sent);
    }
    ::Ice::AsyncResultPtr
    begin_GetProtect(const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_GetProtect(0, ::Ice::newCallback(__completed, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_GetProtect(const ::Ice::Context& __ctx, const ::IceInternal::Function<void (bool)>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return __begin_GetProtect(&__ctx, __response, __exception, __sent);
    }
    ::Ice::AsyncResultPtr
    begin_GetProtect(const ::Ice::Context& __ctx, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_GetProtect(&__ctx, ::Ice::newCallback(__completed, __sent));
    }

private:

    ::Ice::AsyncResultPtr __begin_GetProtect(const ::Ice::Context* __ctx, const ::IceInternal::Function<void (bool)>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception, const ::IceInternal::Function<void (bool)>& __sent);

public:
#endif

    ::Ice::AsyncResultPtr begin_GetProtect()
    {
        return begin_GetProtect(0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_GetProtect(const ::Ice::Context& __ctx)
    {
        return begin_GetProtect(&__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_GetProtect(const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_GetProtect(0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_GetProtect(const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_GetProtect(&__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_GetProtect(const ::Robot::Callback_Motor_GetProtectPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_GetProtect(0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_GetProtect(const ::Ice::Context& __ctx, const ::Robot::Callback_Motor_GetProtectPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_GetProtect(&__ctx, __del, __cookie);
    }

    bool end_GetProtect(const ::Ice::AsyncResultPtr&);

private:

    bool GetProtect(const ::Ice::Context*);
    ::Ice::AsyncResultPtr begin_GetProtect(const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);

public:

    ::IceInternal::ProxyHandle<Motor> ice_context(const ::Ice::Context& __context) const
    {
        return dynamic_cast<Motor*>(::IceProxy::Ice::Object::ice_context(__context).get());
    }

    ::IceInternal::ProxyHandle<Motor> ice_adapterId(const ::std::string& __id) const
    {
        return dynamic_cast<Motor*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
    }

    ::IceInternal::ProxyHandle<Motor> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
    {
        return dynamic_cast<Motor*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
    }

    ::IceInternal::ProxyHandle<Motor> ice_locatorCacheTimeout(int __timeout) const
    {
        return dynamic_cast<Motor*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
    }

    ::IceInternal::ProxyHandle<Motor> ice_connectionCached(bool __cached) const
    {
        return dynamic_cast<Motor*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
    }

    ::IceInternal::ProxyHandle<Motor> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
    {
        return dynamic_cast<Motor*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
    }

    ::IceInternal::ProxyHandle<Motor> ice_secure(bool __secure) const
    {
        return dynamic_cast<Motor*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
    }

    ::IceInternal::ProxyHandle<Motor> ice_preferSecure(bool __preferSecure) const
    {
        return dynamic_cast<Motor*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
    }

    ::IceInternal::ProxyHandle<Motor> ice_router(const ::Ice::RouterPrx& __router) const
    {
        return dynamic_cast<Motor*>(::IceProxy::Ice::Object::ice_router(__router).get());
    }

    ::IceInternal::ProxyHandle<Motor> ice_locator(const ::Ice::LocatorPrx& __locator) const
    {
        return dynamic_cast<Motor*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
    }

    ::IceInternal::ProxyHandle<Motor> ice_collocationOptimized(bool __co) const
    {
        return dynamic_cast<Motor*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
    }

    ::IceInternal::ProxyHandle<Motor> ice_invocationTimeout(int __timeout) const
    {
        return dynamic_cast<Motor*>(::IceProxy::Ice::Object::ice_invocationTimeout(__timeout).get());
    }

    ::IceInternal::ProxyHandle<Motor> ice_twoway() const
    {
        return dynamic_cast<Motor*>(::IceProxy::Ice::Object::ice_twoway().get());
    }

    ::IceInternal::ProxyHandle<Motor> ice_oneway() const
    {
        return dynamic_cast<Motor*>(::IceProxy::Ice::Object::ice_oneway().get());
    }

    ::IceInternal::ProxyHandle<Motor> ice_batchOneway() const
    {
        return dynamic_cast<Motor*>(::IceProxy::Ice::Object::ice_batchOneway().get());
    }

    ::IceInternal::ProxyHandle<Motor> ice_datagram() const
    {
        return dynamic_cast<Motor*>(::IceProxy::Ice::Object::ice_datagram().get());
    }

    ::IceInternal::ProxyHandle<Motor> ice_batchDatagram() const
    {
        return dynamic_cast<Motor*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
    }

    ::IceInternal::ProxyHandle<Motor> ice_compress(bool __compress) const
    {
        return dynamic_cast<Motor*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
    }

    ::IceInternal::ProxyHandle<Motor> ice_timeout(int __timeout) const
    {
        return dynamic_cast<Motor*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
    }

    ::IceInternal::ProxyHandle<Motor> ice_connectionId(const ::std::string& __id) const
    {
        return dynamic_cast<Motor*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
    }

    ::IceInternal::ProxyHandle<Motor> ice_encodingVersion(const ::Ice::EncodingVersion& __v) const
    {
        return dynamic_cast<Motor*>(::IceProxy::Ice::Object::ice_encodingVersion(__v).get());
    }

    static const ::std::string& ice_staticId();

private:
    virtual ::IceProxy::Ice::Object* __newInstance() const;
};

class Audio : virtual public ::IceProxy::Ice::Object
{
public:

    void TtsPlayParams(const ::std::string& __p_strTxt, const ::std::string& __p_strSpeaker, ::Ice::Int __p_nSpeed, ::Ice::Int __p_nPitch)
    {
        TtsPlayParams(__p_strTxt, __p_strSpeaker, __p_nSpeed, __p_nPitch, 0);
    }
    void TtsPlayParams(const ::std::string& __p_strTxt, const ::std::string& __p_strSpeaker, ::Ice::Int __p_nSpeed, ::Ice::Int __p_nPitch, const ::Ice::Context& __ctx)
    {
        TtsPlayParams(__p_strTxt, __p_strSpeaker, __p_nSpeed, __p_nPitch, &__ctx);
    }
#ifdef ICE_CPP11
    ::Ice::AsyncResultPtr
    begin_TtsPlayParams(const ::std::string& __p_strTxt, const ::std::string& __p_strSpeaker, ::Ice::Int __p_nSpeed, ::Ice::Int __p_nPitch, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_TtsPlayParams(__p_strTxt, __p_strSpeaker, __p_nSpeed, __p_nPitch, 0, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent));
    }
    ::Ice::AsyncResultPtr
    begin_TtsPlayParams(const ::std::string& __p_strTxt, const ::std::string& __p_strSpeaker, ::Ice::Int __p_nSpeed, ::Ice::Int __p_nPitch, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_TtsPlayParams(__p_strTxt, __p_strSpeaker, __p_nSpeed, __p_nPitch, 0, ::Ice::newCallback(__completed, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_TtsPlayParams(const ::std::string& __p_strTxt, const ::std::string& __p_strSpeaker, ::Ice::Int __p_nSpeed, ::Ice::Int __p_nPitch, const ::Ice::Context& __ctx, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_TtsPlayParams(__p_strTxt, __p_strSpeaker, __p_nSpeed, __p_nPitch, &__ctx, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_TtsPlayParams(const ::std::string& __p_strTxt, const ::std::string& __p_strSpeaker, ::Ice::Int __p_nSpeed, ::Ice::Int __p_nPitch, const ::Ice::Context& __ctx, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_TtsPlayParams(__p_strTxt, __p_strSpeaker, __p_nSpeed, __p_nPitch, &__ctx, ::Ice::newCallback(__completed, __sent));
    }
#endif

    ::Ice::AsyncResultPtr begin_TtsPlayParams(const ::std::string& __p_strTxt, const ::std::string& __p_strSpeaker, ::Ice::Int __p_nSpeed, ::Ice::Int __p_nPitch)
    {
        return begin_TtsPlayParams(__p_strTxt, __p_strSpeaker, __p_nSpeed, __p_nPitch, 0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_TtsPlayParams(const ::std::string& __p_strTxt, const ::std::string& __p_strSpeaker, ::Ice::Int __p_nSpeed, ::Ice::Int __p_nPitch, const ::Ice::Context& __ctx)
    {
        return begin_TtsPlayParams(__p_strTxt, __p_strSpeaker, __p_nSpeed, __p_nPitch, &__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_TtsPlayParams(const ::std::string& __p_strTxt, const ::std::string& __p_strSpeaker, ::Ice::Int __p_nSpeed, ::Ice::Int __p_nPitch, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_TtsPlayParams(__p_strTxt, __p_strSpeaker, __p_nSpeed, __p_nPitch, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_TtsPlayParams(const ::std::string& __p_strTxt, const ::std::string& __p_strSpeaker, ::Ice::Int __p_nSpeed, ::Ice::Int __p_nPitch, const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_TtsPlayParams(__p_strTxt, __p_strSpeaker, __p_nSpeed, __p_nPitch, &__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_TtsPlayParams(const ::std::string& __p_strTxt, const ::std::string& __p_strSpeaker, ::Ice::Int __p_nSpeed, ::Ice::Int __p_nPitch, const ::Robot::Callback_Audio_TtsPlayParamsPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_TtsPlayParams(__p_strTxt, __p_strSpeaker, __p_nSpeed, __p_nPitch, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_TtsPlayParams(const ::std::string& __p_strTxt, const ::std::string& __p_strSpeaker, ::Ice::Int __p_nSpeed, ::Ice::Int __p_nPitch, const ::Ice::Context& __ctx, const ::Robot::Callback_Audio_TtsPlayParamsPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_TtsPlayParams(__p_strTxt, __p_strSpeaker, __p_nSpeed, __p_nPitch, &__ctx, __del, __cookie);
    }

    void end_TtsPlayParams(const ::Ice::AsyncResultPtr&);

private:

    void TtsPlayParams(const ::std::string&, const ::std::string&, ::Ice::Int, ::Ice::Int, const ::Ice::Context*);
    ::Ice::AsyncResultPtr begin_TtsPlayParams(const ::std::string&, const ::std::string&, ::Ice::Int, ::Ice::Int, const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);

public:

    void TtsPlay(const ::std::string& __p_strTxt)
    {
        TtsPlay(__p_strTxt, 0);
    }
    void TtsPlay(const ::std::string& __p_strTxt, const ::Ice::Context& __ctx)
    {
        TtsPlay(__p_strTxt, &__ctx);
    }
#ifdef ICE_CPP11
    ::Ice::AsyncResultPtr
    begin_TtsPlay(const ::std::string& __p_strTxt, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_TtsPlay(__p_strTxt, 0, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent));
    }
    ::Ice::AsyncResultPtr
    begin_TtsPlay(const ::std::string& __p_strTxt, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_TtsPlay(__p_strTxt, 0, ::Ice::newCallback(__completed, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_TtsPlay(const ::std::string& __p_strTxt, const ::Ice::Context& __ctx, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_TtsPlay(__p_strTxt, &__ctx, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_TtsPlay(const ::std::string& __p_strTxt, const ::Ice::Context& __ctx, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_TtsPlay(__p_strTxt, &__ctx, ::Ice::newCallback(__completed, __sent));
    }
#endif

    ::Ice::AsyncResultPtr begin_TtsPlay(const ::std::string& __p_strTxt)
    {
        return begin_TtsPlay(__p_strTxt, 0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_TtsPlay(const ::std::string& __p_strTxt, const ::Ice::Context& __ctx)
    {
        return begin_TtsPlay(__p_strTxt, &__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_TtsPlay(const ::std::string& __p_strTxt, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_TtsPlay(__p_strTxt, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_TtsPlay(const ::std::string& __p_strTxt, const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_TtsPlay(__p_strTxt, &__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_TtsPlay(const ::std::string& __p_strTxt, const ::Robot::Callback_Audio_TtsPlayPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_TtsPlay(__p_strTxt, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_TtsPlay(const ::std::string& __p_strTxt, const ::Ice::Context& __ctx, const ::Robot::Callback_Audio_TtsPlayPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_TtsPlay(__p_strTxt, &__ctx, __del, __cookie);
    }

    void end_TtsPlay(const ::Ice::AsyncResultPtr&);

private:

    void TtsPlay(const ::std::string&, const ::Ice::Context*);
    ::Ice::AsyncResultPtr begin_TtsPlay(const ::std::string&, const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);

public:

    void TtsPlayFile(const ::std::string& __p_strPath)
    {
        TtsPlayFile(__p_strPath, 0);
    }
    void TtsPlayFile(const ::std::string& __p_strPath, const ::Ice::Context& __ctx)
    {
        TtsPlayFile(__p_strPath, &__ctx);
    }
#ifdef ICE_CPP11
    ::Ice::AsyncResultPtr
    begin_TtsPlayFile(const ::std::string& __p_strPath, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_TtsPlayFile(__p_strPath, 0, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent));
    }
    ::Ice::AsyncResultPtr
    begin_TtsPlayFile(const ::std::string& __p_strPath, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_TtsPlayFile(__p_strPath, 0, ::Ice::newCallback(__completed, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_TtsPlayFile(const ::std::string& __p_strPath, const ::Ice::Context& __ctx, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_TtsPlayFile(__p_strPath, &__ctx, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_TtsPlayFile(const ::std::string& __p_strPath, const ::Ice::Context& __ctx, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_TtsPlayFile(__p_strPath, &__ctx, ::Ice::newCallback(__completed, __sent));
    }
#endif

    ::Ice::AsyncResultPtr begin_TtsPlayFile(const ::std::string& __p_strPath)
    {
        return begin_TtsPlayFile(__p_strPath, 0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_TtsPlayFile(const ::std::string& __p_strPath, const ::Ice::Context& __ctx)
    {
        return begin_TtsPlayFile(__p_strPath, &__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_TtsPlayFile(const ::std::string& __p_strPath, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_TtsPlayFile(__p_strPath, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_TtsPlayFile(const ::std::string& __p_strPath, const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_TtsPlayFile(__p_strPath, &__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_TtsPlayFile(const ::std::string& __p_strPath, const ::Robot::Callback_Audio_TtsPlayFilePtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_TtsPlayFile(__p_strPath, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_TtsPlayFile(const ::std::string& __p_strPath, const ::Ice::Context& __ctx, const ::Robot::Callback_Audio_TtsPlayFilePtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_TtsPlayFile(__p_strPath, &__ctx, __del, __cookie);
    }

    void end_TtsPlayFile(const ::Ice::AsyncResultPtr&);

private:

    void TtsPlayFile(const ::std::string&, const ::Ice::Context*);
    ::Ice::AsyncResultPtr begin_TtsPlayFile(const ::std::string&, const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);

public:

    void TtsSetVolume(::Ice::Int __p_nVal)
    {
        TtsSetVolume(__p_nVal, 0);
    }
    void TtsSetVolume(::Ice::Int __p_nVal, const ::Ice::Context& __ctx)
    {
        TtsSetVolume(__p_nVal, &__ctx);
    }
#ifdef ICE_CPP11
    ::Ice::AsyncResultPtr
    begin_TtsSetVolume(::Ice::Int __p_nVal, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_TtsSetVolume(__p_nVal, 0, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent));
    }
    ::Ice::AsyncResultPtr
    begin_TtsSetVolume(::Ice::Int __p_nVal, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_TtsSetVolume(__p_nVal, 0, ::Ice::newCallback(__completed, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_TtsSetVolume(::Ice::Int __p_nVal, const ::Ice::Context& __ctx, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_TtsSetVolume(__p_nVal, &__ctx, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_TtsSetVolume(::Ice::Int __p_nVal, const ::Ice::Context& __ctx, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_TtsSetVolume(__p_nVal, &__ctx, ::Ice::newCallback(__completed, __sent));
    }
#endif

    ::Ice::AsyncResultPtr begin_TtsSetVolume(::Ice::Int __p_nVal)
    {
        return begin_TtsSetVolume(__p_nVal, 0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_TtsSetVolume(::Ice::Int __p_nVal, const ::Ice::Context& __ctx)
    {
        return begin_TtsSetVolume(__p_nVal, &__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_TtsSetVolume(::Ice::Int __p_nVal, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_TtsSetVolume(__p_nVal, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_TtsSetVolume(::Ice::Int __p_nVal, const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_TtsSetVolume(__p_nVal, &__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_TtsSetVolume(::Ice::Int __p_nVal, const ::Robot::Callback_Audio_TtsSetVolumePtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_TtsSetVolume(__p_nVal, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_TtsSetVolume(::Ice::Int __p_nVal, const ::Ice::Context& __ctx, const ::Robot::Callback_Audio_TtsSetVolumePtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_TtsSetVolume(__p_nVal, &__ctx, __del, __cookie);
    }

    void end_TtsSetVolume(const ::Ice::AsyncResultPtr&);

private:

    void TtsSetVolume(::Ice::Int, const ::Ice::Context*);
    ::Ice::AsyncResultPtr begin_TtsSetVolume(::Ice::Int, const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);

public:

    void TtsStop()
    {
        TtsStop(0);
    }
    void TtsStop(const ::Ice::Context& __ctx)
    {
        TtsStop(&__ctx);
    }
#ifdef ICE_CPP11
    ::Ice::AsyncResultPtr
    begin_TtsStop(const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_TtsStop(0, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent));
    }
    ::Ice::AsyncResultPtr
    begin_TtsStop(const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_TtsStop(0, ::Ice::newCallback(__completed, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_TtsStop(const ::Ice::Context& __ctx, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_TtsStop(&__ctx, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_TtsStop(const ::Ice::Context& __ctx, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_TtsStop(&__ctx, ::Ice::newCallback(__completed, __sent));
    }
#endif

    ::Ice::AsyncResultPtr begin_TtsStop()
    {
        return begin_TtsStop(0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_TtsStop(const ::Ice::Context& __ctx)
    {
        return begin_TtsStop(&__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_TtsStop(const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_TtsStop(0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_TtsStop(const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_TtsStop(&__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_TtsStop(const ::Robot::Callback_Audio_TtsStopPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_TtsStop(0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_TtsStop(const ::Ice::Context& __ctx, const ::Robot::Callback_Audio_TtsStopPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_TtsStop(&__ctx, __del, __cookie);
    }

    void end_TtsStop(const ::Ice::AsyncResultPtr&);

private:

    void TtsStop(const ::Ice::Context*);
    ::Ice::AsyncResultPtr begin_TtsStop(const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);

public:

    bool TtsIsPlaying()
    {
        return TtsIsPlaying(0);
    }
    bool TtsIsPlaying(const ::Ice::Context& __ctx)
    {
        return TtsIsPlaying(&__ctx);
    }
#ifdef ICE_CPP11
    ::Ice::AsyncResultPtr
    begin_TtsIsPlaying(const ::IceInternal::Function<void (bool)>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return __begin_TtsIsPlaying(0, __response, __exception, __sent);
    }
    ::Ice::AsyncResultPtr
    begin_TtsIsPlaying(const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_TtsIsPlaying(0, ::Ice::newCallback(__completed, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_TtsIsPlaying(const ::Ice::Context& __ctx, const ::IceInternal::Function<void (bool)>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return __begin_TtsIsPlaying(&__ctx, __response, __exception, __sent);
    }
    ::Ice::AsyncResultPtr
    begin_TtsIsPlaying(const ::Ice::Context& __ctx, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_TtsIsPlaying(&__ctx, ::Ice::newCallback(__completed, __sent));
    }

private:

    ::Ice::AsyncResultPtr __begin_TtsIsPlaying(const ::Ice::Context* __ctx, const ::IceInternal::Function<void (bool)>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception, const ::IceInternal::Function<void (bool)>& __sent);

public:
#endif

    ::Ice::AsyncResultPtr begin_TtsIsPlaying()
    {
        return begin_TtsIsPlaying(0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_TtsIsPlaying(const ::Ice::Context& __ctx)
    {
        return begin_TtsIsPlaying(&__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_TtsIsPlaying(const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_TtsIsPlaying(0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_TtsIsPlaying(const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_TtsIsPlaying(&__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_TtsIsPlaying(const ::Robot::Callback_Audio_TtsIsPlayingPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_TtsIsPlaying(0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_TtsIsPlaying(const ::Ice::Context& __ctx, const ::Robot::Callback_Audio_TtsIsPlayingPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_TtsIsPlaying(&__ctx, __del, __cookie);
    }

    bool end_TtsIsPlaying(const ::Ice::AsyncResultPtr&);

private:

    bool TtsIsPlaying(const ::Ice::Context*);
    ::Ice::AsyncResultPtr begin_TtsIsPlaying(const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);

public:

    void AsrBuildCmd(const ::Ice::StringSeq& __p_strCmdList)
    {
        AsrBuildCmd(__p_strCmdList, 0);
    }
    void AsrBuildCmd(const ::Ice::StringSeq& __p_strCmdList, const ::Ice::Context& __ctx)
    {
        AsrBuildCmd(__p_strCmdList, &__ctx);
    }
#ifdef ICE_CPP11
    ::Ice::AsyncResultPtr
    begin_AsrBuildCmd(const ::Ice::StringSeq& __p_strCmdList, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_AsrBuildCmd(__p_strCmdList, 0, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent));
    }
    ::Ice::AsyncResultPtr
    begin_AsrBuildCmd(const ::Ice::StringSeq& __p_strCmdList, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_AsrBuildCmd(__p_strCmdList, 0, ::Ice::newCallback(__completed, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_AsrBuildCmd(const ::Ice::StringSeq& __p_strCmdList, const ::Ice::Context& __ctx, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_AsrBuildCmd(__p_strCmdList, &__ctx, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_AsrBuildCmd(const ::Ice::StringSeq& __p_strCmdList, const ::Ice::Context& __ctx, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_AsrBuildCmd(__p_strCmdList, &__ctx, ::Ice::newCallback(__completed, __sent));
    }
#endif

    ::Ice::AsyncResultPtr begin_AsrBuildCmd(const ::Ice::StringSeq& __p_strCmdList)
    {
        return begin_AsrBuildCmd(__p_strCmdList, 0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_AsrBuildCmd(const ::Ice::StringSeq& __p_strCmdList, const ::Ice::Context& __ctx)
    {
        return begin_AsrBuildCmd(__p_strCmdList, &__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_AsrBuildCmd(const ::Ice::StringSeq& __p_strCmdList, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_AsrBuildCmd(__p_strCmdList, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_AsrBuildCmd(const ::Ice::StringSeq& __p_strCmdList, const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_AsrBuildCmd(__p_strCmdList, &__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_AsrBuildCmd(const ::Ice::StringSeq& __p_strCmdList, const ::Robot::Callback_Audio_AsrBuildCmdPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_AsrBuildCmd(__p_strCmdList, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_AsrBuildCmd(const ::Ice::StringSeq& __p_strCmdList, const ::Ice::Context& __ctx, const ::Robot::Callback_Audio_AsrBuildCmdPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_AsrBuildCmd(__p_strCmdList, &__ctx, __del, __cookie);
    }

    void end_AsrBuildCmd(const ::Ice::AsyncResultPtr&);

private:

    void AsrBuildCmd(const ::Ice::StringSeq&, const ::Ice::Context*);
    ::Ice::AsyncResultPtr begin_AsrBuildCmd(const ::Ice::StringSeq&, const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);

public:

    void AsrStart(::Ice::Int __p_nMaxDelayMs)
    {
        AsrStart(__p_nMaxDelayMs, 0);
    }
    void AsrStart(::Ice::Int __p_nMaxDelayMs, const ::Ice::Context& __ctx)
    {
        AsrStart(__p_nMaxDelayMs, &__ctx);
    }
#ifdef ICE_CPP11
    ::Ice::AsyncResultPtr
    begin_AsrStart(::Ice::Int __p_nMaxDelayMs, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_AsrStart(__p_nMaxDelayMs, 0, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent));
    }
    ::Ice::AsyncResultPtr
    begin_AsrStart(::Ice::Int __p_nMaxDelayMs, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_AsrStart(__p_nMaxDelayMs, 0, ::Ice::newCallback(__completed, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_AsrStart(::Ice::Int __p_nMaxDelayMs, const ::Ice::Context& __ctx, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_AsrStart(__p_nMaxDelayMs, &__ctx, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_AsrStart(::Ice::Int __p_nMaxDelayMs, const ::Ice::Context& __ctx, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_AsrStart(__p_nMaxDelayMs, &__ctx, ::Ice::newCallback(__completed, __sent));
    }
#endif

    ::Ice::AsyncResultPtr begin_AsrStart(::Ice::Int __p_nMaxDelayMs)
    {
        return begin_AsrStart(__p_nMaxDelayMs, 0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_AsrStart(::Ice::Int __p_nMaxDelayMs, const ::Ice::Context& __ctx)
    {
        return begin_AsrStart(__p_nMaxDelayMs, &__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_AsrStart(::Ice::Int __p_nMaxDelayMs, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_AsrStart(__p_nMaxDelayMs, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_AsrStart(::Ice::Int __p_nMaxDelayMs, const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_AsrStart(__p_nMaxDelayMs, &__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_AsrStart(::Ice::Int __p_nMaxDelayMs, const ::Robot::Callback_Audio_AsrStartPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_AsrStart(__p_nMaxDelayMs, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_AsrStart(::Ice::Int __p_nMaxDelayMs, const ::Ice::Context& __ctx, const ::Robot::Callback_Audio_AsrStartPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_AsrStart(__p_nMaxDelayMs, &__ctx, __del, __cookie);
    }

    void end_AsrStart(const ::Ice::AsyncResultPtr&);

private:

    void AsrStart(::Ice::Int, const ::Ice::Context*);
    ::Ice::AsyncResultPtr begin_AsrStart(::Ice::Int, const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);

public:

    void AsrStop()
    {
        AsrStop(0);
    }
    void AsrStop(const ::Ice::Context& __ctx)
    {
        AsrStop(&__ctx);
    }
#ifdef ICE_CPP11
    ::Ice::AsyncResultPtr
    begin_AsrStop(const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_AsrStop(0, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent));
    }
    ::Ice::AsyncResultPtr
    begin_AsrStop(const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_AsrStop(0, ::Ice::newCallback(__completed, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_AsrStop(const ::Ice::Context& __ctx, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_AsrStop(&__ctx, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_AsrStop(const ::Ice::Context& __ctx, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_AsrStop(&__ctx, ::Ice::newCallback(__completed, __sent));
    }
#endif

    ::Ice::AsyncResultPtr begin_AsrStop()
    {
        return begin_AsrStop(0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_AsrStop(const ::Ice::Context& __ctx)
    {
        return begin_AsrStop(&__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_AsrStop(const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_AsrStop(0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_AsrStop(const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_AsrStop(&__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_AsrStop(const ::Robot::Callback_Audio_AsrStopPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_AsrStop(0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_AsrStop(const ::Ice::Context& __ctx, const ::Robot::Callback_Audio_AsrStopPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_AsrStop(&__ctx, __del, __cookie);
    }

    void end_AsrStop(const ::Ice::AsyncResultPtr&);

private:

    void AsrStop(const ::Ice::Context*);
    ::Ice::AsyncResultPtr begin_AsrStop(const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);

public:

    void MediaPlay(const ::std::string& __p_strPath)
    {
        MediaPlay(__p_strPath, 0);
    }
    void MediaPlay(const ::std::string& __p_strPath, const ::Ice::Context& __ctx)
    {
        MediaPlay(__p_strPath, &__ctx);
    }
#ifdef ICE_CPP11
    ::Ice::AsyncResultPtr
    begin_MediaPlay(const ::std::string& __p_strPath, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_MediaPlay(__p_strPath, 0, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent));
    }
    ::Ice::AsyncResultPtr
    begin_MediaPlay(const ::std::string& __p_strPath, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_MediaPlay(__p_strPath, 0, ::Ice::newCallback(__completed, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_MediaPlay(const ::std::string& __p_strPath, const ::Ice::Context& __ctx, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_MediaPlay(__p_strPath, &__ctx, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_MediaPlay(const ::std::string& __p_strPath, const ::Ice::Context& __ctx, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_MediaPlay(__p_strPath, &__ctx, ::Ice::newCallback(__completed, __sent));
    }
#endif

    ::Ice::AsyncResultPtr begin_MediaPlay(const ::std::string& __p_strPath)
    {
        return begin_MediaPlay(__p_strPath, 0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_MediaPlay(const ::std::string& __p_strPath, const ::Ice::Context& __ctx)
    {
        return begin_MediaPlay(__p_strPath, &__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_MediaPlay(const ::std::string& __p_strPath, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_MediaPlay(__p_strPath, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_MediaPlay(const ::std::string& __p_strPath, const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_MediaPlay(__p_strPath, &__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_MediaPlay(const ::std::string& __p_strPath, const ::Robot::Callback_Audio_MediaPlayPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_MediaPlay(__p_strPath, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_MediaPlay(const ::std::string& __p_strPath, const ::Ice::Context& __ctx, const ::Robot::Callback_Audio_MediaPlayPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_MediaPlay(__p_strPath, &__ctx, __del, __cookie);
    }

    void end_MediaPlay(const ::Ice::AsyncResultPtr&);

private:

    void MediaPlay(const ::std::string&, const ::Ice::Context*);
    ::Ice::AsyncResultPtr begin_MediaPlay(const ::std::string&, const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);

public:

    void MediaSetVolume(::Ice::Int __p_nVal)
    {
        MediaSetVolume(__p_nVal, 0);
    }
    void MediaSetVolume(::Ice::Int __p_nVal, const ::Ice::Context& __ctx)
    {
        MediaSetVolume(__p_nVal, &__ctx);
    }
#ifdef ICE_CPP11
    ::Ice::AsyncResultPtr
    begin_MediaSetVolume(::Ice::Int __p_nVal, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_MediaSetVolume(__p_nVal, 0, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent));
    }
    ::Ice::AsyncResultPtr
    begin_MediaSetVolume(::Ice::Int __p_nVal, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_MediaSetVolume(__p_nVal, 0, ::Ice::newCallback(__completed, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_MediaSetVolume(::Ice::Int __p_nVal, const ::Ice::Context& __ctx, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_MediaSetVolume(__p_nVal, &__ctx, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_MediaSetVolume(::Ice::Int __p_nVal, const ::Ice::Context& __ctx, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_MediaSetVolume(__p_nVal, &__ctx, ::Ice::newCallback(__completed, __sent));
    }
#endif

    ::Ice::AsyncResultPtr begin_MediaSetVolume(::Ice::Int __p_nVal)
    {
        return begin_MediaSetVolume(__p_nVal, 0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_MediaSetVolume(::Ice::Int __p_nVal, const ::Ice::Context& __ctx)
    {
        return begin_MediaSetVolume(__p_nVal, &__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_MediaSetVolume(::Ice::Int __p_nVal, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_MediaSetVolume(__p_nVal, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_MediaSetVolume(::Ice::Int __p_nVal, const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_MediaSetVolume(__p_nVal, &__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_MediaSetVolume(::Ice::Int __p_nVal, const ::Robot::Callback_Audio_MediaSetVolumePtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_MediaSetVolume(__p_nVal, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_MediaSetVolume(::Ice::Int __p_nVal, const ::Ice::Context& __ctx, const ::Robot::Callback_Audio_MediaSetVolumePtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_MediaSetVolume(__p_nVal, &__ctx, __del, __cookie);
    }

    void end_MediaSetVolume(const ::Ice::AsyncResultPtr&);

private:

    void MediaSetVolume(::Ice::Int, const ::Ice::Context*);
    ::Ice::AsyncResultPtr begin_MediaSetVolume(::Ice::Int, const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);

public:

    void MediaStop()
    {
        MediaStop(0);
    }
    void MediaStop(const ::Ice::Context& __ctx)
    {
        MediaStop(&__ctx);
    }
#ifdef ICE_CPP11
    ::Ice::AsyncResultPtr
    begin_MediaStop(const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_MediaStop(0, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent));
    }
    ::Ice::AsyncResultPtr
    begin_MediaStop(const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_MediaStop(0, ::Ice::newCallback(__completed, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_MediaStop(const ::Ice::Context& __ctx, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_MediaStop(&__ctx, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_MediaStop(const ::Ice::Context& __ctx, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_MediaStop(&__ctx, ::Ice::newCallback(__completed, __sent));
    }
#endif

    ::Ice::AsyncResultPtr begin_MediaStop()
    {
        return begin_MediaStop(0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_MediaStop(const ::Ice::Context& __ctx)
    {
        return begin_MediaStop(&__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_MediaStop(const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_MediaStop(0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_MediaStop(const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_MediaStop(&__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_MediaStop(const ::Robot::Callback_Audio_MediaStopPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_MediaStop(0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_MediaStop(const ::Ice::Context& __ctx, const ::Robot::Callback_Audio_MediaStopPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_MediaStop(&__ctx, __del, __cookie);
    }

    void end_MediaStop(const ::Ice::AsyncResultPtr&);

private:

    void MediaStop(const ::Ice::Context*);
    ::Ice::AsyncResultPtr begin_MediaStop(const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);

public:

    bool MediaIsPlaying()
    {
        return MediaIsPlaying(0);
    }
    bool MediaIsPlaying(const ::Ice::Context& __ctx)
    {
        return MediaIsPlaying(&__ctx);
    }
#ifdef ICE_CPP11
    ::Ice::AsyncResultPtr
    begin_MediaIsPlaying(const ::IceInternal::Function<void (bool)>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return __begin_MediaIsPlaying(0, __response, __exception, __sent);
    }
    ::Ice::AsyncResultPtr
    begin_MediaIsPlaying(const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_MediaIsPlaying(0, ::Ice::newCallback(__completed, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_MediaIsPlaying(const ::Ice::Context& __ctx, const ::IceInternal::Function<void (bool)>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return __begin_MediaIsPlaying(&__ctx, __response, __exception, __sent);
    }
    ::Ice::AsyncResultPtr
    begin_MediaIsPlaying(const ::Ice::Context& __ctx, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_MediaIsPlaying(&__ctx, ::Ice::newCallback(__completed, __sent));
    }

private:

    ::Ice::AsyncResultPtr __begin_MediaIsPlaying(const ::Ice::Context* __ctx, const ::IceInternal::Function<void (bool)>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception, const ::IceInternal::Function<void (bool)>& __sent);

public:
#endif

    ::Ice::AsyncResultPtr begin_MediaIsPlaying()
    {
        return begin_MediaIsPlaying(0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_MediaIsPlaying(const ::Ice::Context& __ctx)
    {
        return begin_MediaIsPlaying(&__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_MediaIsPlaying(const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_MediaIsPlaying(0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_MediaIsPlaying(const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_MediaIsPlaying(&__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_MediaIsPlaying(const ::Robot::Callback_Audio_MediaIsPlayingPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_MediaIsPlaying(0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_MediaIsPlaying(const ::Ice::Context& __ctx, const ::Robot::Callback_Audio_MediaIsPlayingPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_MediaIsPlaying(&__ctx, __del, __cookie);
    }

    bool end_MediaIsPlaying(const ::Ice::AsyncResultPtr&);

private:

    bool MediaIsPlaying(const ::Ice::Context*);
    ::Ice::AsyncResultPtr begin_MediaIsPlaying(const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);

public:

    ::IceInternal::ProxyHandle<Audio> ice_context(const ::Ice::Context& __context) const
    {
        return dynamic_cast<Audio*>(::IceProxy::Ice::Object::ice_context(__context).get());
    }

    ::IceInternal::ProxyHandle<Audio> ice_adapterId(const ::std::string& __id) const
    {
        return dynamic_cast<Audio*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
    }

    ::IceInternal::ProxyHandle<Audio> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
    {
        return dynamic_cast<Audio*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
    }

    ::IceInternal::ProxyHandle<Audio> ice_locatorCacheTimeout(int __timeout) const
    {
        return dynamic_cast<Audio*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
    }

    ::IceInternal::ProxyHandle<Audio> ice_connectionCached(bool __cached) const
    {
        return dynamic_cast<Audio*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
    }

    ::IceInternal::ProxyHandle<Audio> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
    {
        return dynamic_cast<Audio*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
    }

    ::IceInternal::ProxyHandle<Audio> ice_secure(bool __secure) const
    {
        return dynamic_cast<Audio*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
    }

    ::IceInternal::ProxyHandle<Audio> ice_preferSecure(bool __preferSecure) const
    {
        return dynamic_cast<Audio*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
    }

    ::IceInternal::ProxyHandle<Audio> ice_router(const ::Ice::RouterPrx& __router) const
    {
        return dynamic_cast<Audio*>(::IceProxy::Ice::Object::ice_router(__router).get());
    }

    ::IceInternal::ProxyHandle<Audio> ice_locator(const ::Ice::LocatorPrx& __locator) const
    {
        return dynamic_cast<Audio*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
    }

    ::IceInternal::ProxyHandle<Audio> ice_collocationOptimized(bool __co) const
    {
        return dynamic_cast<Audio*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
    }

    ::IceInternal::ProxyHandle<Audio> ice_invocationTimeout(int __timeout) const
    {
        return dynamic_cast<Audio*>(::IceProxy::Ice::Object::ice_invocationTimeout(__timeout).get());
    }

    ::IceInternal::ProxyHandle<Audio> ice_twoway() const
    {
        return dynamic_cast<Audio*>(::IceProxy::Ice::Object::ice_twoway().get());
    }

    ::IceInternal::ProxyHandle<Audio> ice_oneway() const
    {
        return dynamic_cast<Audio*>(::IceProxy::Ice::Object::ice_oneway().get());
    }

    ::IceInternal::ProxyHandle<Audio> ice_batchOneway() const
    {
        return dynamic_cast<Audio*>(::IceProxy::Ice::Object::ice_batchOneway().get());
    }

    ::IceInternal::ProxyHandle<Audio> ice_datagram() const
    {
        return dynamic_cast<Audio*>(::IceProxy::Ice::Object::ice_datagram().get());
    }

    ::IceInternal::ProxyHandle<Audio> ice_batchDatagram() const
    {
        return dynamic_cast<Audio*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
    }

    ::IceInternal::ProxyHandle<Audio> ice_compress(bool __compress) const
    {
        return dynamic_cast<Audio*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
    }

    ::IceInternal::ProxyHandle<Audio> ice_timeout(int __timeout) const
    {
        return dynamic_cast<Audio*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
    }

    ::IceInternal::ProxyHandle<Audio> ice_connectionId(const ::std::string& __id) const
    {
        return dynamic_cast<Audio*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
    }

    ::IceInternal::ProxyHandle<Audio> ice_encodingVersion(const ::Ice::EncodingVersion& __v) const
    {
        return dynamic_cast<Audio*>(::IceProxy::Ice::Object::ice_encodingVersion(__v).get());
    }

    static const ::std::string& ice_staticId();

private:
    virtual ::IceProxy::Ice::Object* __newInstance() const;
};

class ScreenEx : virtual public ::IceProxy::Ice::Object
{
public:

    void ShowRepeatDir(::Ice::Int __p_nDelay, const ::std::string& __p_strDir)
    {
        ShowRepeatDir(__p_nDelay, __p_strDir, 0);
    }
    void ShowRepeatDir(::Ice::Int __p_nDelay, const ::std::string& __p_strDir, const ::Ice::Context& __ctx)
    {
        ShowRepeatDir(__p_nDelay, __p_strDir, &__ctx);
    }
#ifdef ICE_CPP11
    ::Ice::AsyncResultPtr
    begin_ShowRepeatDir(::Ice::Int __p_nDelay, const ::std::string& __p_strDir, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_ShowRepeatDir(__p_nDelay, __p_strDir, 0, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent));
    }
    ::Ice::AsyncResultPtr
    begin_ShowRepeatDir(::Ice::Int __p_nDelay, const ::std::string& __p_strDir, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_ShowRepeatDir(__p_nDelay, __p_strDir, 0, ::Ice::newCallback(__completed, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_ShowRepeatDir(::Ice::Int __p_nDelay, const ::std::string& __p_strDir, const ::Ice::Context& __ctx, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_ShowRepeatDir(__p_nDelay, __p_strDir, &__ctx, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_ShowRepeatDir(::Ice::Int __p_nDelay, const ::std::string& __p_strDir, const ::Ice::Context& __ctx, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_ShowRepeatDir(__p_nDelay, __p_strDir, &__ctx, ::Ice::newCallback(__completed, __sent));
    }
#endif

    ::Ice::AsyncResultPtr begin_ShowRepeatDir(::Ice::Int __p_nDelay, const ::std::string& __p_strDir)
    {
        return begin_ShowRepeatDir(__p_nDelay, __p_strDir, 0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_ShowRepeatDir(::Ice::Int __p_nDelay, const ::std::string& __p_strDir, const ::Ice::Context& __ctx)
    {
        return begin_ShowRepeatDir(__p_nDelay, __p_strDir, &__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_ShowRepeatDir(::Ice::Int __p_nDelay, const ::std::string& __p_strDir, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_ShowRepeatDir(__p_nDelay, __p_strDir, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_ShowRepeatDir(::Ice::Int __p_nDelay, const ::std::string& __p_strDir, const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_ShowRepeatDir(__p_nDelay, __p_strDir, &__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_ShowRepeatDir(::Ice::Int __p_nDelay, const ::std::string& __p_strDir, const ::Robot::Callback_ScreenEx_ShowRepeatDirPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_ShowRepeatDir(__p_nDelay, __p_strDir, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_ShowRepeatDir(::Ice::Int __p_nDelay, const ::std::string& __p_strDir, const ::Ice::Context& __ctx, const ::Robot::Callback_ScreenEx_ShowRepeatDirPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_ShowRepeatDir(__p_nDelay, __p_strDir, &__ctx, __del, __cookie);
    }

    void end_ShowRepeatDir(const ::Ice::AsyncResultPtr&);

private:

    void ShowRepeatDir(::Ice::Int, const ::std::string&, const ::Ice::Context*);
    ::Ice::AsyncResultPtr begin_ShowRepeatDir(::Ice::Int, const ::std::string&, const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);

public:

    void ShowPic(::Ice::Int __p_nDelay, const ::std::string& __p_strPath)
    {
        ShowPic(__p_nDelay, __p_strPath, 0);
    }
    void ShowPic(::Ice::Int __p_nDelay, const ::std::string& __p_strPath, const ::Ice::Context& __ctx)
    {
        ShowPic(__p_nDelay, __p_strPath, &__ctx);
    }
#ifdef ICE_CPP11
    ::Ice::AsyncResultPtr
    begin_ShowPic(::Ice::Int __p_nDelay, const ::std::string& __p_strPath, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_ShowPic(__p_nDelay, __p_strPath, 0, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent));
    }
    ::Ice::AsyncResultPtr
    begin_ShowPic(::Ice::Int __p_nDelay, const ::std::string& __p_strPath, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_ShowPic(__p_nDelay, __p_strPath, 0, ::Ice::newCallback(__completed, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_ShowPic(::Ice::Int __p_nDelay, const ::std::string& __p_strPath, const ::Ice::Context& __ctx, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_ShowPic(__p_nDelay, __p_strPath, &__ctx, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_ShowPic(::Ice::Int __p_nDelay, const ::std::string& __p_strPath, const ::Ice::Context& __ctx, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_ShowPic(__p_nDelay, __p_strPath, &__ctx, ::Ice::newCallback(__completed, __sent));
    }
#endif

    ::Ice::AsyncResultPtr begin_ShowPic(::Ice::Int __p_nDelay, const ::std::string& __p_strPath)
    {
        return begin_ShowPic(__p_nDelay, __p_strPath, 0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_ShowPic(::Ice::Int __p_nDelay, const ::std::string& __p_strPath, const ::Ice::Context& __ctx)
    {
        return begin_ShowPic(__p_nDelay, __p_strPath, &__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_ShowPic(::Ice::Int __p_nDelay, const ::std::string& __p_strPath, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_ShowPic(__p_nDelay, __p_strPath, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_ShowPic(::Ice::Int __p_nDelay, const ::std::string& __p_strPath, const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_ShowPic(__p_nDelay, __p_strPath, &__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_ShowPic(::Ice::Int __p_nDelay, const ::std::string& __p_strPath, const ::Robot::Callback_ScreenEx_ShowPicPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_ShowPic(__p_nDelay, __p_strPath, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_ShowPic(::Ice::Int __p_nDelay, const ::std::string& __p_strPath, const ::Ice::Context& __ctx, const ::Robot::Callback_ScreenEx_ShowPicPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_ShowPic(__p_nDelay, __p_strPath, &__ctx, __del, __cookie);
    }

    void end_ShowPic(const ::Ice::AsyncResultPtr&);

private:

    void ShowPic(::Ice::Int, const ::std::string&, const ::Ice::Context*);
    ::Ice::AsyncResultPtr begin_ShowPic(::Ice::Int, const ::std::string&, const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);

public:

    void ShowVideo(::Ice::Int __p_nDelay, const ::std::string& __p_strPath)
    {
        ShowVideo(__p_nDelay, __p_strPath, 0);
    }
    void ShowVideo(::Ice::Int __p_nDelay, const ::std::string& __p_strPath, const ::Ice::Context& __ctx)
    {
        ShowVideo(__p_nDelay, __p_strPath, &__ctx);
    }
#ifdef ICE_CPP11
    ::Ice::AsyncResultPtr
    begin_ShowVideo(::Ice::Int __p_nDelay, const ::std::string& __p_strPath, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_ShowVideo(__p_nDelay, __p_strPath, 0, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent));
    }
    ::Ice::AsyncResultPtr
    begin_ShowVideo(::Ice::Int __p_nDelay, const ::std::string& __p_strPath, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_ShowVideo(__p_nDelay, __p_strPath, 0, ::Ice::newCallback(__completed, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_ShowVideo(::Ice::Int __p_nDelay, const ::std::string& __p_strPath, const ::Ice::Context& __ctx, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_ShowVideo(__p_nDelay, __p_strPath, &__ctx, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_ShowVideo(::Ice::Int __p_nDelay, const ::std::string& __p_strPath, const ::Ice::Context& __ctx, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_ShowVideo(__p_nDelay, __p_strPath, &__ctx, ::Ice::newCallback(__completed, __sent));
    }
#endif

    ::Ice::AsyncResultPtr begin_ShowVideo(::Ice::Int __p_nDelay, const ::std::string& __p_strPath)
    {
        return begin_ShowVideo(__p_nDelay, __p_strPath, 0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_ShowVideo(::Ice::Int __p_nDelay, const ::std::string& __p_strPath, const ::Ice::Context& __ctx)
    {
        return begin_ShowVideo(__p_nDelay, __p_strPath, &__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_ShowVideo(::Ice::Int __p_nDelay, const ::std::string& __p_strPath, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_ShowVideo(__p_nDelay, __p_strPath, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_ShowVideo(::Ice::Int __p_nDelay, const ::std::string& __p_strPath, const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_ShowVideo(__p_nDelay, __p_strPath, &__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_ShowVideo(::Ice::Int __p_nDelay, const ::std::string& __p_strPath, const ::Robot::Callback_ScreenEx_ShowVideoPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_ShowVideo(__p_nDelay, __p_strPath, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_ShowVideo(::Ice::Int __p_nDelay, const ::std::string& __p_strPath, const ::Ice::Context& __ctx, const ::Robot::Callback_ScreenEx_ShowVideoPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_ShowVideo(__p_nDelay, __p_strPath, &__ctx, __del, __cookie);
    }

    void end_ShowVideo(const ::Ice::AsyncResultPtr&);

private:

    void ShowVideo(::Ice::Int, const ::std::string&, const ::Ice::Context*);
    ::Ice::AsyncResultPtr begin_ShowVideo(::Ice::Int, const ::std::string&, const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);

public:

    void Clean()
    {
        Clean(0);
    }
    void Clean(const ::Ice::Context& __ctx)
    {
        Clean(&__ctx);
    }
#ifdef ICE_CPP11
    ::Ice::AsyncResultPtr
    begin_Clean(const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_Clean(0, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent));
    }
    ::Ice::AsyncResultPtr
    begin_Clean(const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_Clean(0, ::Ice::newCallback(__completed, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_Clean(const ::Ice::Context& __ctx, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_Clean(&__ctx, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_Clean(const ::Ice::Context& __ctx, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_Clean(&__ctx, ::Ice::newCallback(__completed, __sent));
    }
#endif

    ::Ice::AsyncResultPtr begin_Clean()
    {
        return begin_Clean(0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_Clean(const ::Ice::Context& __ctx)
    {
        return begin_Clean(&__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_Clean(const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_Clean(0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_Clean(const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_Clean(&__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_Clean(const ::Robot::Callback_ScreenEx_CleanPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_Clean(0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_Clean(const ::Ice::Context& __ctx, const ::Robot::Callback_ScreenEx_CleanPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_Clean(&__ctx, __del, __cookie);
    }

    void end_Clean(const ::Ice::AsyncResultPtr&);

private:

    void Clean(const ::Ice::Context*);
    ::Ice::AsyncResultPtr begin_Clean(const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);

public:

    void ShowVip(const ::std::string& __p_strName, const ::std::string& __p_strImg)
    {
        ShowVip(__p_strName, __p_strImg, 0);
    }
    void ShowVip(const ::std::string& __p_strName, const ::std::string& __p_strImg, const ::Ice::Context& __ctx)
    {
        ShowVip(__p_strName, __p_strImg, &__ctx);
    }
#ifdef ICE_CPP11
    ::Ice::AsyncResultPtr
    begin_ShowVip(const ::std::string& __p_strName, const ::std::string& __p_strImg, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_ShowVip(__p_strName, __p_strImg, 0, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent));
    }
    ::Ice::AsyncResultPtr
    begin_ShowVip(const ::std::string& __p_strName, const ::std::string& __p_strImg, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_ShowVip(__p_strName, __p_strImg, 0, ::Ice::newCallback(__completed, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_ShowVip(const ::std::string& __p_strName, const ::std::string& __p_strImg, const ::Ice::Context& __ctx, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_ShowVip(__p_strName, __p_strImg, &__ctx, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_ShowVip(const ::std::string& __p_strName, const ::std::string& __p_strImg, const ::Ice::Context& __ctx, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_ShowVip(__p_strName, __p_strImg, &__ctx, ::Ice::newCallback(__completed, __sent));
    }
#endif

    ::Ice::AsyncResultPtr begin_ShowVip(const ::std::string& __p_strName, const ::std::string& __p_strImg)
    {
        return begin_ShowVip(__p_strName, __p_strImg, 0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_ShowVip(const ::std::string& __p_strName, const ::std::string& __p_strImg, const ::Ice::Context& __ctx)
    {
        return begin_ShowVip(__p_strName, __p_strImg, &__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_ShowVip(const ::std::string& __p_strName, const ::std::string& __p_strImg, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_ShowVip(__p_strName, __p_strImg, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_ShowVip(const ::std::string& __p_strName, const ::std::string& __p_strImg, const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_ShowVip(__p_strName, __p_strImg, &__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_ShowVip(const ::std::string& __p_strName, const ::std::string& __p_strImg, const ::Robot::Callback_ScreenEx_ShowVipPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_ShowVip(__p_strName, __p_strImg, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_ShowVip(const ::std::string& __p_strName, const ::std::string& __p_strImg, const ::Ice::Context& __ctx, const ::Robot::Callback_ScreenEx_ShowVipPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_ShowVip(__p_strName, __p_strImg, &__ctx, __del, __cookie);
    }

    void end_ShowVip(const ::Ice::AsyncResultPtr&);

private:

    void ShowVip(const ::std::string&, const ::std::string&, const ::Ice::Context*);
    ::Ice::AsyncResultPtr begin_ShowVip(const ::std::string&, const ::std::string&, const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);

public:

    void ShowBarrage(::Ice::Int __p_nDelay, const ::std::string& __p_strTxt)
    {
        ShowBarrage(__p_nDelay, __p_strTxt, 0);
    }
    void ShowBarrage(::Ice::Int __p_nDelay, const ::std::string& __p_strTxt, const ::Ice::Context& __ctx)
    {
        ShowBarrage(__p_nDelay, __p_strTxt, &__ctx);
    }
#ifdef ICE_CPP11
    ::Ice::AsyncResultPtr
    begin_ShowBarrage(::Ice::Int __p_nDelay, const ::std::string& __p_strTxt, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_ShowBarrage(__p_nDelay, __p_strTxt, 0, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent));
    }
    ::Ice::AsyncResultPtr
    begin_ShowBarrage(::Ice::Int __p_nDelay, const ::std::string& __p_strTxt, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_ShowBarrage(__p_nDelay, __p_strTxt, 0, ::Ice::newCallback(__completed, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_ShowBarrage(::Ice::Int __p_nDelay, const ::std::string& __p_strTxt, const ::Ice::Context& __ctx, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_ShowBarrage(__p_nDelay, __p_strTxt, &__ctx, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_ShowBarrage(::Ice::Int __p_nDelay, const ::std::string& __p_strTxt, const ::Ice::Context& __ctx, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_ShowBarrage(__p_nDelay, __p_strTxt, &__ctx, ::Ice::newCallback(__completed, __sent));
    }
#endif

    ::Ice::AsyncResultPtr begin_ShowBarrage(::Ice::Int __p_nDelay, const ::std::string& __p_strTxt)
    {
        return begin_ShowBarrage(__p_nDelay, __p_strTxt, 0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_ShowBarrage(::Ice::Int __p_nDelay, const ::std::string& __p_strTxt, const ::Ice::Context& __ctx)
    {
        return begin_ShowBarrage(__p_nDelay, __p_strTxt, &__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_ShowBarrage(::Ice::Int __p_nDelay, const ::std::string& __p_strTxt, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_ShowBarrage(__p_nDelay, __p_strTxt, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_ShowBarrage(::Ice::Int __p_nDelay, const ::std::string& __p_strTxt, const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_ShowBarrage(__p_nDelay, __p_strTxt, &__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_ShowBarrage(::Ice::Int __p_nDelay, const ::std::string& __p_strTxt, const ::Robot::Callback_ScreenEx_ShowBarragePtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_ShowBarrage(__p_nDelay, __p_strTxt, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_ShowBarrage(::Ice::Int __p_nDelay, const ::std::string& __p_strTxt, const ::Ice::Context& __ctx, const ::Robot::Callback_ScreenEx_ShowBarragePtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_ShowBarrage(__p_nDelay, __p_strTxt, &__ctx, __del, __cookie);
    }

    void end_ShowBarrage(const ::Ice::AsyncResultPtr&);

private:

    void ShowBarrage(::Ice::Int, const ::std::string&, const ::Ice::Context*);
    ::Ice::AsyncResultPtr begin_ShowBarrage(::Ice::Int, const ::std::string&, const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);

public:

    ::IceInternal::ProxyHandle<ScreenEx> ice_context(const ::Ice::Context& __context) const
    {
        return dynamic_cast<ScreenEx*>(::IceProxy::Ice::Object::ice_context(__context).get());
    }

    ::IceInternal::ProxyHandle<ScreenEx> ice_adapterId(const ::std::string& __id) const
    {
        return dynamic_cast<ScreenEx*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
    }

    ::IceInternal::ProxyHandle<ScreenEx> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
    {
        return dynamic_cast<ScreenEx*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
    }

    ::IceInternal::ProxyHandle<ScreenEx> ice_locatorCacheTimeout(int __timeout) const
    {
        return dynamic_cast<ScreenEx*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
    }

    ::IceInternal::ProxyHandle<ScreenEx> ice_connectionCached(bool __cached) const
    {
        return dynamic_cast<ScreenEx*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
    }

    ::IceInternal::ProxyHandle<ScreenEx> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
    {
        return dynamic_cast<ScreenEx*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
    }

    ::IceInternal::ProxyHandle<ScreenEx> ice_secure(bool __secure) const
    {
        return dynamic_cast<ScreenEx*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
    }

    ::IceInternal::ProxyHandle<ScreenEx> ice_preferSecure(bool __preferSecure) const
    {
        return dynamic_cast<ScreenEx*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
    }

    ::IceInternal::ProxyHandle<ScreenEx> ice_router(const ::Ice::RouterPrx& __router) const
    {
        return dynamic_cast<ScreenEx*>(::IceProxy::Ice::Object::ice_router(__router).get());
    }

    ::IceInternal::ProxyHandle<ScreenEx> ice_locator(const ::Ice::LocatorPrx& __locator) const
    {
        return dynamic_cast<ScreenEx*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
    }

    ::IceInternal::ProxyHandle<ScreenEx> ice_collocationOptimized(bool __co) const
    {
        return dynamic_cast<ScreenEx*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
    }

    ::IceInternal::ProxyHandle<ScreenEx> ice_invocationTimeout(int __timeout) const
    {
        return dynamic_cast<ScreenEx*>(::IceProxy::Ice::Object::ice_invocationTimeout(__timeout).get());
    }

    ::IceInternal::ProxyHandle<ScreenEx> ice_twoway() const
    {
        return dynamic_cast<ScreenEx*>(::IceProxy::Ice::Object::ice_twoway().get());
    }

    ::IceInternal::ProxyHandle<ScreenEx> ice_oneway() const
    {
        return dynamic_cast<ScreenEx*>(::IceProxy::Ice::Object::ice_oneway().get());
    }

    ::IceInternal::ProxyHandle<ScreenEx> ice_batchOneway() const
    {
        return dynamic_cast<ScreenEx*>(::IceProxy::Ice::Object::ice_batchOneway().get());
    }

    ::IceInternal::ProxyHandle<ScreenEx> ice_datagram() const
    {
        return dynamic_cast<ScreenEx*>(::IceProxy::Ice::Object::ice_datagram().get());
    }

    ::IceInternal::ProxyHandle<ScreenEx> ice_batchDatagram() const
    {
        return dynamic_cast<ScreenEx*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
    }

    ::IceInternal::ProxyHandle<ScreenEx> ice_compress(bool __compress) const
    {
        return dynamic_cast<ScreenEx*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
    }

    ::IceInternal::ProxyHandle<ScreenEx> ice_timeout(int __timeout) const
    {
        return dynamic_cast<ScreenEx*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
    }

    ::IceInternal::ProxyHandle<ScreenEx> ice_connectionId(const ::std::string& __id) const
    {
        return dynamic_cast<ScreenEx*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
    }

    ::IceInternal::ProxyHandle<ScreenEx> ice_encodingVersion(const ::Ice::EncodingVersion& __v) const
    {
        return dynamic_cast<ScreenEx*>(::IceProxy::Ice::Object::ice_encodingVersion(__v).get());
    }

    static const ::std::string& ice_staticId();

private:
    virtual ::IceProxy::Ice::Object* __newInstance() const;
};

class Config : virtual public ::IceProxy::Ice::Object
{
public:

    void SetSystemVolume(::Ice::Int __p_nVal)
    {
        SetSystemVolume(__p_nVal, 0);
    }
    void SetSystemVolume(::Ice::Int __p_nVal, const ::Ice::Context& __ctx)
    {
        SetSystemVolume(__p_nVal, &__ctx);
    }
#ifdef ICE_CPP11
    ::Ice::AsyncResultPtr
    begin_SetSystemVolume(::Ice::Int __p_nVal, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_SetSystemVolume(__p_nVal, 0, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent));
    }
    ::Ice::AsyncResultPtr
    begin_SetSystemVolume(::Ice::Int __p_nVal, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_SetSystemVolume(__p_nVal, 0, ::Ice::newCallback(__completed, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_SetSystemVolume(::Ice::Int __p_nVal, const ::Ice::Context& __ctx, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_SetSystemVolume(__p_nVal, &__ctx, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_SetSystemVolume(::Ice::Int __p_nVal, const ::Ice::Context& __ctx, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_SetSystemVolume(__p_nVal, &__ctx, ::Ice::newCallback(__completed, __sent));
    }
#endif

    ::Ice::AsyncResultPtr begin_SetSystemVolume(::Ice::Int __p_nVal)
    {
        return begin_SetSystemVolume(__p_nVal, 0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_SetSystemVolume(::Ice::Int __p_nVal, const ::Ice::Context& __ctx)
    {
        return begin_SetSystemVolume(__p_nVal, &__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_SetSystemVolume(::Ice::Int __p_nVal, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_SetSystemVolume(__p_nVal, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_SetSystemVolume(::Ice::Int __p_nVal, const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_SetSystemVolume(__p_nVal, &__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_SetSystemVolume(::Ice::Int __p_nVal, const ::Robot::Callback_Config_SetSystemVolumePtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_SetSystemVolume(__p_nVal, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_SetSystemVolume(::Ice::Int __p_nVal, const ::Ice::Context& __ctx, const ::Robot::Callback_Config_SetSystemVolumePtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_SetSystemVolume(__p_nVal, &__ctx, __del, __cookie);
    }

    void end_SetSystemVolume(const ::Ice::AsyncResultPtr&);

private:

    void SetSystemVolume(::Ice::Int, const ::Ice::Context*);
    ::Ice::AsyncResultPtr begin_SetSystemVolume(::Ice::Int, const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);

public:

    ::Ice::Int GetSystemVolume()
    {
        return GetSystemVolume(0);
    }
    ::Ice::Int GetSystemVolume(const ::Ice::Context& __ctx)
    {
        return GetSystemVolume(&__ctx);
    }
#ifdef ICE_CPP11
    ::Ice::AsyncResultPtr
    begin_GetSystemVolume(const ::IceInternal::Function<void (::Ice::Int)>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return __begin_GetSystemVolume(0, __response, __exception, __sent);
    }
    ::Ice::AsyncResultPtr
    begin_GetSystemVolume(const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_GetSystemVolume(0, ::Ice::newCallback(__completed, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_GetSystemVolume(const ::Ice::Context& __ctx, const ::IceInternal::Function<void (::Ice::Int)>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return __begin_GetSystemVolume(&__ctx, __response, __exception, __sent);
    }
    ::Ice::AsyncResultPtr
    begin_GetSystemVolume(const ::Ice::Context& __ctx, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_GetSystemVolume(&__ctx, ::Ice::newCallback(__completed, __sent));
    }

private:

    ::Ice::AsyncResultPtr __begin_GetSystemVolume(const ::Ice::Context* __ctx, const ::IceInternal::Function<void (::Ice::Int)>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception, const ::IceInternal::Function<void (bool)>& __sent);

public:
#endif

    ::Ice::AsyncResultPtr begin_GetSystemVolume()
    {
        return begin_GetSystemVolume(0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_GetSystemVolume(const ::Ice::Context& __ctx)
    {
        return begin_GetSystemVolume(&__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_GetSystemVolume(const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_GetSystemVolume(0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_GetSystemVolume(const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_GetSystemVolume(&__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_GetSystemVolume(const ::Robot::Callback_Config_GetSystemVolumePtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_GetSystemVolume(0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_GetSystemVolume(const ::Ice::Context& __ctx, const ::Robot::Callback_Config_GetSystemVolumePtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_GetSystemVolume(&__ctx, __del, __cookie);
    }

    ::Ice::Int end_GetSystemVolume(const ::Ice::AsyncResultPtr&);

private:

    ::Ice::Int GetSystemVolume(const ::Ice::Context*);
    ::Ice::AsyncResultPtr begin_GetSystemVolume(const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);

public:

    void SetSystemCmd(const ::std::string& __p_strCmd)
    {
        SetSystemCmd(__p_strCmd, 0);
    }
    void SetSystemCmd(const ::std::string& __p_strCmd, const ::Ice::Context& __ctx)
    {
        SetSystemCmd(__p_strCmd, &__ctx);
    }
#ifdef ICE_CPP11
    ::Ice::AsyncResultPtr
    begin_SetSystemCmd(const ::std::string& __p_strCmd, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_SetSystemCmd(__p_strCmd, 0, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent));
    }
    ::Ice::AsyncResultPtr
    begin_SetSystemCmd(const ::std::string& __p_strCmd, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_SetSystemCmd(__p_strCmd, 0, ::Ice::newCallback(__completed, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_SetSystemCmd(const ::std::string& __p_strCmd, const ::Ice::Context& __ctx, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_SetSystemCmd(__p_strCmd, &__ctx, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_SetSystemCmd(const ::std::string& __p_strCmd, const ::Ice::Context& __ctx, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_SetSystemCmd(__p_strCmd, &__ctx, ::Ice::newCallback(__completed, __sent));
    }
#endif

    ::Ice::AsyncResultPtr begin_SetSystemCmd(const ::std::string& __p_strCmd)
    {
        return begin_SetSystemCmd(__p_strCmd, 0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_SetSystemCmd(const ::std::string& __p_strCmd, const ::Ice::Context& __ctx)
    {
        return begin_SetSystemCmd(__p_strCmd, &__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_SetSystemCmd(const ::std::string& __p_strCmd, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_SetSystemCmd(__p_strCmd, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_SetSystemCmd(const ::std::string& __p_strCmd, const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_SetSystemCmd(__p_strCmd, &__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_SetSystemCmd(const ::std::string& __p_strCmd, const ::Robot::Callback_Config_SetSystemCmdPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_SetSystemCmd(__p_strCmd, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_SetSystemCmd(const ::std::string& __p_strCmd, const ::Ice::Context& __ctx, const ::Robot::Callback_Config_SetSystemCmdPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_SetSystemCmd(__p_strCmd, &__ctx, __del, __cookie);
    }

    void end_SetSystemCmd(const ::Ice::AsyncResultPtr&);

private:

    void SetSystemCmd(const ::std::string&, const ::Ice::Context*);
    ::Ice::AsyncResultPtr begin_SetSystemCmd(const ::std::string&, const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);

public:

    ::IceInternal::ProxyHandle<Config> ice_context(const ::Ice::Context& __context) const
    {
        return dynamic_cast<Config*>(::IceProxy::Ice::Object::ice_context(__context).get());
    }

    ::IceInternal::ProxyHandle<Config> ice_adapterId(const ::std::string& __id) const
    {
        return dynamic_cast<Config*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
    }

    ::IceInternal::ProxyHandle<Config> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
    {
        return dynamic_cast<Config*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
    }

    ::IceInternal::ProxyHandle<Config> ice_locatorCacheTimeout(int __timeout) const
    {
        return dynamic_cast<Config*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
    }

    ::IceInternal::ProxyHandle<Config> ice_connectionCached(bool __cached) const
    {
        return dynamic_cast<Config*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
    }

    ::IceInternal::ProxyHandle<Config> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
    {
        return dynamic_cast<Config*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
    }

    ::IceInternal::ProxyHandle<Config> ice_secure(bool __secure) const
    {
        return dynamic_cast<Config*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
    }

    ::IceInternal::ProxyHandle<Config> ice_preferSecure(bool __preferSecure) const
    {
        return dynamic_cast<Config*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
    }

    ::IceInternal::ProxyHandle<Config> ice_router(const ::Ice::RouterPrx& __router) const
    {
        return dynamic_cast<Config*>(::IceProxy::Ice::Object::ice_router(__router).get());
    }

    ::IceInternal::ProxyHandle<Config> ice_locator(const ::Ice::LocatorPrx& __locator) const
    {
        return dynamic_cast<Config*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
    }

    ::IceInternal::ProxyHandle<Config> ice_collocationOptimized(bool __co) const
    {
        return dynamic_cast<Config*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
    }

    ::IceInternal::ProxyHandle<Config> ice_invocationTimeout(int __timeout) const
    {
        return dynamic_cast<Config*>(::IceProxy::Ice::Object::ice_invocationTimeout(__timeout).get());
    }

    ::IceInternal::ProxyHandle<Config> ice_twoway() const
    {
        return dynamic_cast<Config*>(::IceProxy::Ice::Object::ice_twoway().get());
    }

    ::IceInternal::ProxyHandle<Config> ice_oneway() const
    {
        return dynamic_cast<Config*>(::IceProxy::Ice::Object::ice_oneway().get());
    }

    ::IceInternal::ProxyHandle<Config> ice_batchOneway() const
    {
        return dynamic_cast<Config*>(::IceProxy::Ice::Object::ice_batchOneway().get());
    }

    ::IceInternal::ProxyHandle<Config> ice_datagram() const
    {
        return dynamic_cast<Config*>(::IceProxy::Ice::Object::ice_datagram().get());
    }

    ::IceInternal::ProxyHandle<Config> ice_batchDatagram() const
    {
        return dynamic_cast<Config*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
    }

    ::IceInternal::ProxyHandle<Config> ice_compress(bool __compress) const
    {
        return dynamic_cast<Config*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
    }

    ::IceInternal::ProxyHandle<Config> ice_timeout(int __timeout) const
    {
        return dynamic_cast<Config*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
    }

    ::IceInternal::ProxyHandle<Config> ice_connectionId(const ::std::string& __id) const
    {
        return dynamic_cast<Config*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
    }

    ::IceInternal::ProxyHandle<Config> ice_encodingVersion(const ::Ice::EncodingVersion& __v) const
    {
        return dynamic_cast<Config*>(::IceProxy::Ice::Object::ice_encodingVersion(__v).get());
    }

    static const ::std::string& ice_staticId();

private:
    virtual ::IceProxy::Ice::Object* __newInstance() const;
};

class Pub : virtual public ::IceProxy::Ice::Object
{
public:

    void Notify(const ::std::string& __p_strType, const ::std::string& __p_msg)
    {
        Notify(__p_strType, __p_msg, 0);
    }
    void Notify(const ::std::string& __p_strType, const ::std::string& __p_msg, const ::Ice::Context& __ctx)
    {
        Notify(__p_strType, __p_msg, &__ctx);
    }
#ifdef ICE_CPP11
    ::Ice::AsyncResultPtr
    begin_Notify(const ::std::string& __p_strType, const ::std::string& __p_msg, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_Notify(__p_strType, __p_msg, 0, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent));
    }
    ::Ice::AsyncResultPtr
    begin_Notify(const ::std::string& __p_strType, const ::std::string& __p_msg, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_Notify(__p_strType, __p_msg, 0, ::Ice::newCallback(__completed, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_Notify(const ::std::string& __p_strType, const ::std::string& __p_msg, const ::Ice::Context& __ctx, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_Notify(__p_strType, __p_msg, &__ctx, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_Notify(const ::std::string& __p_strType, const ::std::string& __p_msg, const ::Ice::Context& __ctx, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_Notify(__p_strType, __p_msg, &__ctx, ::Ice::newCallback(__completed, __sent));
    }
#endif

    ::Ice::AsyncResultPtr begin_Notify(const ::std::string& __p_strType, const ::std::string& __p_msg)
    {
        return begin_Notify(__p_strType, __p_msg, 0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_Notify(const ::std::string& __p_strType, const ::std::string& __p_msg, const ::Ice::Context& __ctx)
    {
        return begin_Notify(__p_strType, __p_msg, &__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_Notify(const ::std::string& __p_strType, const ::std::string& __p_msg, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_Notify(__p_strType, __p_msg, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_Notify(const ::std::string& __p_strType, const ::std::string& __p_msg, const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_Notify(__p_strType, __p_msg, &__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_Notify(const ::std::string& __p_strType, const ::std::string& __p_msg, const ::Robot::Callback_Pub_NotifyPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_Notify(__p_strType, __p_msg, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_Notify(const ::std::string& __p_strType, const ::std::string& __p_msg, const ::Ice::Context& __ctx, const ::Robot::Callback_Pub_NotifyPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_Notify(__p_strType, __p_msg, &__ctx, __del, __cookie);
    }

    void end_Notify(const ::Ice::AsyncResultPtr&);

private:

    void Notify(const ::std::string&, const ::std::string&, const ::Ice::Context*);
    ::Ice::AsyncResultPtr begin_Notify(const ::std::string&, const ::std::string&, const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);

public:

    ::IceInternal::ProxyHandle<Pub> ice_context(const ::Ice::Context& __context) const
    {
        return dynamic_cast<Pub*>(::IceProxy::Ice::Object::ice_context(__context).get());
    }

    ::IceInternal::ProxyHandle<Pub> ice_adapterId(const ::std::string& __id) const
    {
        return dynamic_cast<Pub*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
    }

    ::IceInternal::ProxyHandle<Pub> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
    {
        return dynamic_cast<Pub*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
    }

    ::IceInternal::ProxyHandle<Pub> ice_locatorCacheTimeout(int __timeout) const
    {
        return dynamic_cast<Pub*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
    }

    ::IceInternal::ProxyHandle<Pub> ice_connectionCached(bool __cached) const
    {
        return dynamic_cast<Pub*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
    }

    ::IceInternal::ProxyHandle<Pub> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
    {
        return dynamic_cast<Pub*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
    }

    ::IceInternal::ProxyHandle<Pub> ice_secure(bool __secure) const
    {
        return dynamic_cast<Pub*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
    }

    ::IceInternal::ProxyHandle<Pub> ice_preferSecure(bool __preferSecure) const
    {
        return dynamic_cast<Pub*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
    }

    ::IceInternal::ProxyHandle<Pub> ice_router(const ::Ice::RouterPrx& __router) const
    {
        return dynamic_cast<Pub*>(::IceProxy::Ice::Object::ice_router(__router).get());
    }

    ::IceInternal::ProxyHandle<Pub> ice_locator(const ::Ice::LocatorPrx& __locator) const
    {
        return dynamic_cast<Pub*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
    }

    ::IceInternal::ProxyHandle<Pub> ice_collocationOptimized(bool __co) const
    {
        return dynamic_cast<Pub*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
    }

    ::IceInternal::ProxyHandle<Pub> ice_invocationTimeout(int __timeout) const
    {
        return dynamic_cast<Pub*>(::IceProxy::Ice::Object::ice_invocationTimeout(__timeout).get());
    }

    ::IceInternal::ProxyHandle<Pub> ice_twoway() const
    {
        return dynamic_cast<Pub*>(::IceProxy::Ice::Object::ice_twoway().get());
    }

    ::IceInternal::ProxyHandle<Pub> ice_oneway() const
    {
        return dynamic_cast<Pub*>(::IceProxy::Ice::Object::ice_oneway().get());
    }

    ::IceInternal::ProxyHandle<Pub> ice_batchOneway() const
    {
        return dynamic_cast<Pub*>(::IceProxy::Ice::Object::ice_batchOneway().get());
    }

    ::IceInternal::ProxyHandle<Pub> ice_datagram() const
    {
        return dynamic_cast<Pub*>(::IceProxy::Ice::Object::ice_datagram().get());
    }

    ::IceInternal::ProxyHandle<Pub> ice_batchDatagram() const
    {
        return dynamic_cast<Pub*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
    }

    ::IceInternal::ProxyHandle<Pub> ice_compress(bool __compress) const
    {
        return dynamic_cast<Pub*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
    }

    ::IceInternal::ProxyHandle<Pub> ice_timeout(int __timeout) const
    {
        return dynamic_cast<Pub*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
    }

    ::IceInternal::ProxyHandle<Pub> ice_connectionId(const ::std::string& __id) const
    {
        return dynamic_cast<Pub*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
    }

    ::IceInternal::ProxyHandle<Pub> ice_encodingVersion(const ::Ice::EncodingVersion& __v) const
    {
        return dynamic_cast<Pub*>(::IceProxy::Ice::Object::ice_encodingVersion(__v).get());
    }

    static const ::std::string& ice_staticId();

private:
    virtual ::IceProxy::Ice::Object* __newInstance() const;
};

class Session : virtual public ::IceProxy::Ice::Object
{
public:

    void List(::Ice::StringSeq& __p_sList)
    {
        List(__p_sList, 0);
    }
    void List(::Ice::StringSeq& __p_sList, const ::Ice::Context& __ctx)
    {
        List(__p_sList, &__ctx);
    }
#ifdef ICE_CPP11
    ::Ice::AsyncResultPtr
    begin_List(const ::IceInternal::Function<void (const ::Ice::StringSeq&)>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return __begin_List(0, __response, __exception, __sent);
    }
    ::Ice::AsyncResultPtr
    begin_List(const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_List(0, ::Ice::newCallback(__completed, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_List(const ::Ice::Context& __ctx, const ::IceInternal::Function<void (const ::Ice::StringSeq&)>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return __begin_List(&__ctx, __response, __exception, __sent);
    }
    ::Ice::AsyncResultPtr
    begin_List(const ::Ice::Context& __ctx, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_List(&__ctx, ::Ice::newCallback(__completed, __sent));
    }

private:

    ::Ice::AsyncResultPtr __begin_List(const ::Ice::Context* __ctx, const ::IceInternal::Function<void (const ::Ice::StringSeq&)>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception, const ::IceInternal::Function<void (bool)>& __sent);

public:
#endif

    ::Ice::AsyncResultPtr begin_List()
    {
        return begin_List(0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_List(const ::Ice::Context& __ctx)
    {
        return begin_List(&__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_List(const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_List(0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_List(const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_List(&__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_List(const ::Robot::Callback_Session_ListPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_List(0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_List(const ::Ice::Context& __ctx, const ::Robot::Callback_Session_ListPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_List(&__ctx, __del, __cookie);
    }

    void end_List(::Ice::StringSeq& __p_sList, const ::Ice::AsyncResultPtr&);

private:

    void List(::Ice::StringSeq&, const ::Ice::Context*);
    ::Ice::AsyncResultPtr begin_List(const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);

public:

    ::IceInternal::ProxyHandle<Session> ice_context(const ::Ice::Context& __context) const
    {
        return dynamic_cast<Session*>(::IceProxy::Ice::Object::ice_context(__context).get());
    }

    ::IceInternal::ProxyHandle<Session> ice_adapterId(const ::std::string& __id) const
    {
        return dynamic_cast<Session*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
    }

    ::IceInternal::ProxyHandle<Session> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
    {
        return dynamic_cast<Session*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
    }

    ::IceInternal::ProxyHandle<Session> ice_locatorCacheTimeout(int __timeout) const
    {
        return dynamic_cast<Session*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
    }

    ::IceInternal::ProxyHandle<Session> ice_connectionCached(bool __cached) const
    {
        return dynamic_cast<Session*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
    }

    ::IceInternal::ProxyHandle<Session> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
    {
        return dynamic_cast<Session*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
    }

    ::IceInternal::ProxyHandle<Session> ice_secure(bool __secure) const
    {
        return dynamic_cast<Session*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
    }

    ::IceInternal::ProxyHandle<Session> ice_preferSecure(bool __preferSecure) const
    {
        return dynamic_cast<Session*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
    }

    ::IceInternal::ProxyHandle<Session> ice_router(const ::Ice::RouterPrx& __router) const
    {
        return dynamic_cast<Session*>(::IceProxy::Ice::Object::ice_router(__router).get());
    }

    ::IceInternal::ProxyHandle<Session> ice_locator(const ::Ice::LocatorPrx& __locator) const
    {
        return dynamic_cast<Session*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
    }

    ::IceInternal::ProxyHandle<Session> ice_collocationOptimized(bool __co) const
    {
        return dynamic_cast<Session*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
    }

    ::IceInternal::ProxyHandle<Session> ice_invocationTimeout(int __timeout) const
    {
        return dynamic_cast<Session*>(::IceProxy::Ice::Object::ice_invocationTimeout(__timeout).get());
    }

    ::IceInternal::ProxyHandle<Session> ice_twoway() const
    {
        return dynamic_cast<Session*>(::IceProxy::Ice::Object::ice_twoway().get());
    }

    ::IceInternal::ProxyHandle<Session> ice_oneway() const
    {
        return dynamic_cast<Session*>(::IceProxy::Ice::Object::ice_oneway().get());
    }

    ::IceInternal::ProxyHandle<Session> ice_batchOneway() const
    {
        return dynamic_cast<Session*>(::IceProxy::Ice::Object::ice_batchOneway().get());
    }

    ::IceInternal::ProxyHandle<Session> ice_datagram() const
    {
        return dynamic_cast<Session*>(::IceProxy::Ice::Object::ice_datagram().get());
    }

    ::IceInternal::ProxyHandle<Session> ice_batchDatagram() const
    {
        return dynamic_cast<Session*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
    }

    ::IceInternal::ProxyHandle<Session> ice_compress(bool __compress) const
    {
        return dynamic_cast<Session*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
    }

    ::IceInternal::ProxyHandle<Session> ice_timeout(int __timeout) const
    {
        return dynamic_cast<Session*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
    }

    ::IceInternal::ProxyHandle<Session> ice_connectionId(const ::std::string& __id) const
    {
        return dynamic_cast<Session*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
    }

    ::IceInternal::ProxyHandle<Session> ice_encodingVersion(const ::Ice::EncodingVersion& __v) const
    {
        return dynamic_cast<Session*>(::IceProxy::Ice::Object::ice_encodingVersion(__v).get());
    }

    static const ::std::string& ice_staticId();

private:
    virtual ::IceProxy::Ice::Object* __newInstance() const;
};

class Live : virtual public ::IceProxy::Ice::Object
{
public:

    void RemoteRecvStart()
    {
        RemoteRecvStart(0);
    }
    void RemoteRecvStart(const ::Ice::Context& __ctx)
    {
        RemoteRecvStart(&__ctx);
    }
#ifdef ICE_CPP11
    ::Ice::AsyncResultPtr
    begin_RemoteRecvStart(const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_RemoteRecvStart(0, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent));
    }
    ::Ice::AsyncResultPtr
    begin_RemoteRecvStart(const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_RemoteRecvStart(0, ::Ice::newCallback(__completed, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_RemoteRecvStart(const ::Ice::Context& __ctx, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_RemoteRecvStart(&__ctx, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_RemoteRecvStart(const ::Ice::Context& __ctx, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_RemoteRecvStart(&__ctx, ::Ice::newCallback(__completed, __sent));
    }
#endif

    ::Ice::AsyncResultPtr begin_RemoteRecvStart()
    {
        return begin_RemoteRecvStart(0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_RemoteRecvStart(const ::Ice::Context& __ctx)
    {
        return begin_RemoteRecvStart(&__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_RemoteRecvStart(const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_RemoteRecvStart(0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_RemoteRecvStart(const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_RemoteRecvStart(&__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_RemoteRecvStart(const ::Robot::Callback_Live_RemoteRecvStartPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_RemoteRecvStart(0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_RemoteRecvStart(const ::Ice::Context& __ctx, const ::Robot::Callback_Live_RemoteRecvStartPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_RemoteRecvStart(&__ctx, __del, __cookie);
    }

    void end_RemoteRecvStart(const ::Ice::AsyncResultPtr&);

private:

    void RemoteRecvStart(const ::Ice::Context*);
    ::Ice::AsyncResultPtr begin_RemoteRecvStart(const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);

public:

    void RemoteRecvStop()
    {
        RemoteRecvStop(0);
    }
    void RemoteRecvStop(const ::Ice::Context& __ctx)
    {
        RemoteRecvStop(&__ctx);
    }
#ifdef ICE_CPP11
    ::Ice::AsyncResultPtr
    begin_RemoteRecvStop(const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_RemoteRecvStop(0, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent));
    }
    ::Ice::AsyncResultPtr
    begin_RemoteRecvStop(const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_RemoteRecvStop(0, ::Ice::newCallback(__completed, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_RemoteRecvStop(const ::Ice::Context& __ctx, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_RemoteRecvStop(&__ctx, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_RemoteRecvStop(const ::Ice::Context& __ctx, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_RemoteRecvStop(&__ctx, ::Ice::newCallback(__completed, __sent));
    }
#endif

    ::Ice::AsyncResultPtr begin_RemoteRecvStop()
    {
        return begin_RemoteRecvStop(0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_RemoteRecvStop(const ::Ice::Context& __ctx)
    {
        return begin_RemoteRecvStop(&__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_RemoteRecvStop(const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_RemoteRecvStop(0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_RemoteRecvStop(const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_RemoteRecvStop(&__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_RemoteRecvStop(const ::Robot::Callback_Live_RemoteRecvStopPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_RemoteRecvStop(0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_RemoteRecvStop(const ::Ice::Context& __ctx, const ::Robot::Callback_Live_RemoteRecvStopPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_RemoteRecvStop(&__ctx, __del, __cookie);
    }

    void end_RemoteRecvStop(const ::Ice::AsyncResultPtr&);

private:

    void RemoteRecvStop(const ::Ice::Context*);
    ::Ice::AsyncResultPtr begin_RemoteRecvStop(const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);

public:

    ::IceInternal::ProxyHandle<Live> ice_context(const ::Ice::Context& __context) const
    {
        return dynamic_cast<Live*>(::IceProxy::Ice::Object::ice_context(__context).get());
    }

    ::IceInternal::ProxyHandle<Live> ice_adapterId(const ::std::string& __id) const
    {
        return dynamic_cast<Live*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
    }

    ::IceInternal::ProxyHandle<Live> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
    {
        return dynamic_cast<Live*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
    }

    ::IceInternal::ProxyHandle<Live> ice_locatorCacheTimeout(int __timeout) const
    {
        return dynamic_cast<Live*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
    }

    ::IceInternal::ProxyHandle<Live> ice_connectionCached(bool __cached) const
    {
        return dynamic_cast<Live*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
    }

    ::IceInternal::ProxyHandle<Live> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
    {
        return dynamic_cast<Live*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
    }

    ::IceInternal::ProxyHandle<Live> ice_secure(bool __secure) const
    {
        return dynamic_cast<Live*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
    }

    ::IceInternal::ProxyHandle<Live> ice_preferSecure(bool __preferSecure) const
    {
        return dynamic_cast<Live*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
    }

    ::IceInternal::ProxyHandle<Live> ice_router(const ::Ice::RouterPrx& __router) const
    {
        return dynamic_cast<Live*>(::IceProxy::Ice::Object::ice_router(__router).get());
    }

    ::IceInternal::ProxyHandle<Live> ice_locator(const ::Ice::LocatorPrx& __locator) const
    {
        return dynamic_cast<Live*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
    }

    ::IceInternal::ProxyHandle<Live> ice_collocationOptimized(bool __co) const
    {
        return dynamic_cast<Live*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
    }

    ::IceInternal::ProxyHandle<Live> ice_invocationTimeout(int __timeout) const
    {
        return dynamic_cast<Live*>(::IceProxy::Ice::Object::ice_invocationTimeout(__timeout).get());
    }

    ::IceInternal::ProxyHandle<Live> ice_twoway() const
    {
        return dynamic_cast<Live*>(::IceProxy::Ice::Object::ice_twoway().get());
    }

    ::IceInternal::ProxyHandle<Live> ice_oneway() const
    {
        return dynamic_cast<Live*>(::IceProxy::Ice::Object::ice_oneway().get());
    }

    ::IceInternal::ProxyHandle<Live> ice_batchOneway() const
    {
        return dynamic_cast<Live*>(::IceProxy::Ice::Object::ice_batchOneway().get());
    }

    ::IceInternal::ProxyHandle<Live> ice_datagram() const
    {
        return dynamic_cast<Live*>(::IceProxy::Ice::Object::ice_datagram().get());
    }

    ::IceInternal::ProxyHandle<Live> ice_batchDatagram() const
    {
        return dynamic_cast<Live*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
    }

    ::IceInternal::ProxyHandle<Live> ice_compress(bool __compress) const
    {
        return dynamic_cast<Live*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
    }

    ::IceInternal::ProxyHandle<Live> ice_timeout(int __timeout) const
    {
        return dynamic_cast<Live*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
    }

    ::IceInternal::ProxyHandle<Live> ice_connectionId(const ::std::string& __id) const
    {
        return dynamic_cast<Live*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
    }

    ::IceInternal::ProxyHandle<Live> ice_encodingVersion(const ::Ice::EncodingVersion& __v) const
    {
        return dynamic_cast<Live*>(::IceProxy::Ice::Object::ice_encodingVersion(__v).get());
    }

    static const ::std::string& ice_staticId();

private:
    virtual ::IceProxy::Ice::Object* __newInstance() const;
};

}

}

namespace Robot
{

class Json : virtual public ::Ice::Object
{
public:

    typedef JsonPrx ProxyType;
    typedef JsonPtr PointerType;

    virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
    virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
    virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
    static const ::std::string& ice_staticId();

    virtual bool Load(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___Load(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual void CallByName(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___CallByName(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual void CallByClass(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___CallByClass(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual void CallByContent(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___CallByContent(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual void Stop(const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___Stop(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual bool IsPlaying(const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___IsPlaying(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual void List(::Ice::StringSeq&, const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___List(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual ::Ice::DispatchStatus __dispatch(::IceInternal::Incoming&, const ::Ice::Current&);

protected:
    virtual void __writeImpl(::IceInternal::BasicStream*) const;
    virtual void __readImpl(::IceInternal::BasicStream*);
    using ::Ice::Object::__writeImpl;
    using ::Ice::Object::__readImpl;
};

inline bool operator==(const Json& l, const Json& r)
{
    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
}

inline bool operator<(const Json& l, const Json& r)
{
    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
}

class Motor : virtual public ::Ice::Object
{
public:

    typedef MotorPrx ProxyType;
    typedef MotorPtr PointerType;

    virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
    virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
    virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
    static const ::std::string& ice_staticId();

    virtual void SerialWrite(const ::Ice::ByteSeq&, const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___SerialWrite(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual void HeadEnable(bool, bool, const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___HeadEnable(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual void HeadLrInit(const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___HeadLrInit(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual void HeadUdInit(const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___HeadUdInit(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual void HeadLrAngle(::Ice::Int, ::Ice::Int, const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___HeadLrAngle(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual void HeadUdAngle(::Ice::Int, ::Ice::Int, const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___HeadUdAngle(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual void HandLEnable(bool, bool, const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___HandLEnable(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual void HandLSwingInit(const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___HandLSwingInit(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual void HandLExpandInit(const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___HandLExpandInit(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual void HandLSwingAngle(::Ice::Int, ::Ice::Int, const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___HandLSwingAngle(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual void HandLExpandAngle(::Ice::Int, ::Ice::Int, const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___HandLExpandAngle(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual void HandREnable(bool, bool, const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___HandREnable(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual void HandRSwingInit(const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___HandRSwingInit(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual void HandRExpandInit(const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___HandRExpandInit(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual void HandRSwingAngle(::Ice::Int, ::Ice::Int, const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___HandRSwingAngle(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual void HandRExpandAngle(::Ice::Int, ::Ice::Int, const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___HandRExpandAngle(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual void WheelEnable(bool, const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___WheelEnable(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual void WheelStop(bool, const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___WheelStop(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual void WheelRotate(::Ice::Int, ::Ice::Int, const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___WheelRotate(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual void WheelRun(::Ice::Int, ::Ice::Int, const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___WheelRun(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual void WheelRunDiff(bool, ::Ice::Int, bool, ::Ice::Int, const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___WheelRunDiff(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual void HeadEye(::Ice::Int, ::Ice::Int, const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___HeadEye(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual void HeadEye2(::Ice::Int, bool, bool, bool, const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___HeadEye2(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual void HeadEar(::Ice::Int, bool, bool, bool, const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___HeadEar(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual void BodyLed(::Ice::Int, bool, bool, bool, const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___BodyLed(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual void TouchSet(bool, ::Ice::Int, ::Ice::Int, const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___TouchSet(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual void SensorBatteryValue(::Ice::IntSeq&, const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___SensorBatteryValue(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual void SensorSonicValue(::Ice::IntSeq&, const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___SensorSonicValue(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual void SensorInfraredValue(::Ice::IntSeq&, const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___SensorInfraredValue(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual void SetProtect(bool, const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___SetProtect(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual bool GetProtect(const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___GetProtect(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual ::Ice::DispatchStatus __dispatch(::IceInternal::Incoming&, const ::Ice::Current&);

protected:
    virtual void __writeImpl(::IceInternal::BasicStream*) const;
    virtual void __readImpl(::IceInternal::BasicStream*);
    using ::Ice::Object::__writeImpl;
    using ::Ice::Object::__readImpl;
};

inline bool operator==(const Motor& l, const Motor& r)
{
    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
}

inline bool operator<(const Motor& l, const Motor& r)
{
    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
}

class Audio : virtual public ::Ice::Object
{
public:

    typedef AudioPrx ProxyType;
    typedef AudioPtr PointerType;

    virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
    virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
    virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
    static const ::std::string& ice_staticId();

    virtual void TtsPlayParams(const ::std::string&, const ::std::string&, ::Ice::Int, ::Ice::Int, const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___TtsPlayParams(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual void TtsPlay(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___TtsPlay(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual void TtsPlayFile(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___TtsPlayFile(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual void TtsSetVolume(::Ice::Int, const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___TtsSetVolume(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual void TtsStop(const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___TtsStop(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual bool TtsIsPlaying(const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___TtsIsPlaying(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual void AsrBuildCmd(const ::Ice::StringSeq&, const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___AsrBuildCmd(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual void AsrStart(::Ice::Int, const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___AsrStart(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual void AsrStop(const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___AsrStop(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual void MediaPlay(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___MediaPlay(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual void MediaSetVolume(::Ice::Int, const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___MediaSetVolume(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual void MediaStop(const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___MediaStop(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual bool MediaIsPlaying(const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___MediaIsPlaying(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual ::Ice::DispatchStatus __dispatch(::IceInternal::Incoming&, const ::Ice::Current&);

protected:
    virtual void __writeImpl(::IceInternal::BasicStream*) const;
    virtual void __readImpl(::IceInternal::BasicStream*);
    using ::Ice::Object::__writeImpl;
    using ::Ice::Object::__readImpl;
};

inline bool operator==(const Audio& l, const Audio& r)
{
    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
}

inline bool operator<(const Audio& l, const Audio& r)
{
    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
}

class ScreenEx : virtual public ::Ice::Object
{
public:

    typedef ScreenExPrx ProxyType;
    typedef ScreenExPtr PointerType;

    virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
    virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
    virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
    static const ::std::string& ice_staticId();

    virtual void ShowRepeatDir(::Ice::Int, const ::std::string&, const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___ShowRepeatDir(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual void ShowPic(::Ice::Int, const ::std::string&, const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___ShowPic(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual void ShowVideo(::Ice::Int, const ::std::string&, const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___ShowVideo(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual void Clean(const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___Clean(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual void ShowVip(const ::std::string&, const ::std::string&, const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___ShowVip(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual void ShowBarrage(::Ice::Int, const ::std::string&, const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___ShowBarrage(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual ::Ice::DispatchStatus __dispatch(::IceInternal::Incoming&, const ::Ice::Current&);

protected:
    virtual void __writeImpl(::IceInternal::BasicStream*) const;
    virtual void __readImpl(::IceInternal::BasicStream*);
    using ::Ice::Object::__writeImpl;
    using ::Ice::Object::__readImpl;
};

inline bool operator==(const ScreenEx& l, const ScreenEx& r)
{
    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
}

inline bool operator<(const ScreenEx& l, const ScreenEx& r)
{
    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
}

class Config : virtual public ::Ice::Object
{
public:

    typedef ConfigPrx ProxyType;
    typedef ConfigPtr PointerType;

    virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
    virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
    virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
    static const ::std::string& ice_staticId();

    virtual void SetSystemVolume(::Ice::Int, const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___SetSystemVolume(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual ::Ice::Int GetSystemVolume(const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___GetSystemVolume(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual void SetSystemCmd(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___SetSystemCmd(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual ::Ice::DispatchStatus __dispatch(::IceInternal::Incoming&, const ::Ice::Current&);

protected:
    virtual void __writeImpl(::IceInternal::BasicStream*) const;
    virtual void __readImpl(::IceInternal::BasicStream*);
    using ::Ice::Object::__writeImpl;
    using ::Ice::Object::__readImpl;
};

inline bool operator==(const Config& l, const Config& r)
{
    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
}

inline bool operator<(const Config& l, const Config& r)
{
    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
}

class Pub : virtual public ::Ice::Object
{
public:

    typedef PubPrx ProxyType;
    typedef PubPtr PointerType;

    virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
    virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
    virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
    static const ::std::string& ice_staticId();

    virtual void Notify(const ::std::string&, const ::std::string&, const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___Notify(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual ::Ice::DispatchStatus __dispatch(::IceInternal::Incoming&, const ::Ice::Current&);

protected:
    virtual void __writeImpl(::IceInternal::BasicStream*) const;
    virtual void __readImpl(::IceInternal::BasicStream*);
    using ::Ice::Object::__writeImpl;
    using ::Ice::Object::__readImpl;
};

inline bool operator==(const Pub& l, const Pub& r)
{
    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
}

inline bool operator<(const Pub& l, const Pub& r)
{
    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
}

class Session : virtual public ::Ice::Object
{
public:

    typedef SessionPrx ProxyType;
    typedef SessionPtr PointerType;

    virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
    virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
    virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
    static const ::std::string& ice_staticId();

    virtual void List(::Ice::StringSeq&, const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___List(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual ::Ice::DispatchStatus __dispatch(::IceInternal::Incoming&, const ::Ice::Current&);

protected:
    virtual void __writeImpl(::IceInternal::BasicStream*) const;
    virtual void __readImpl(::IceInternal::BasicStream*);
    using ::Ice::Object::__writeImpl;
    using ::Ice::Object::__readImpl;
};

inline bool operator==(const Session& l, const Session& r)
{
    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
}

inline bool operator<(const Session& l, const Session& r)
{
    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
}

class Live : virtual public ::Ice::Object
{
public:

    typedef LivePrx ProxyType;
    typedef LivePtr PointerType;

    virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
    virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
    virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
    static const ::std::string& ice_staticId();

    virtual void RemoteRecvStart(const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___RemoteRecvStart(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual void RemoteRecvStop(const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___RemoteRecvStop(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual ::Ice::DispatchStatus __dispatch(::IceInternal::Incoming&, const ::Ice::Current&);

protected:
    virtual void __writeImpl(::IceInternal::BasicStream*) const;
    virtual void __readImpl(::IceInternal::BasicStream*);
    using ::Ice::Object::__writeImpl;
    using ::Ice::Object::__readImpl;
};

inline bool operator==(const Live& l, const Live& r)
{
    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
}

inline bool operator<(const Live& l, const Live& r)
{
    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
}

}

namespace Robot
{

template<class T>
class CallbackNC_Json_Load : public Callback_Json_Load_Base, public ::IceInternal::TwowayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)(bool);

    CallbackNC_Json_Load(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), _response(cb)
    {
    }

    virtual void completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::Robot::JsonPrx __proxy = ::Robot::JsonPrx::uncheckedCast(__result->getProxy());
        bool __ret;
        try
        {
            __ret = __proxy->end_Load(__result);
        }
        catch(const ::Ice::Exception& ex)
        {
            ::IceInternal::CallbackNC<T>::exception(__result, ex);
            return;
        }
        if(_response)
        {
            (::IceInternal::CallbackNC<T>::_callback.get()->*_response)(__ret);
        }
    }

    private:

    Response _response;
};

template<class T> Callback_Json_LoadPtr
newCallback_Json_Load(const IceUtil::Handle<T>& instance, void (T::*cb)(bool), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Json_Load<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Json_LoadPtr
newCallback_Json_Load(T* instance, void (T::*cb)(bool), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Json_Load<T>(instance, cb, excb, sentcb);
}

template<class T, typename CT>
class Callback_Json_Load : public Callback_Json_Load_Base, public ::IceInternal::TwowayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(bool, const CT&);

    Callback_Json_Load(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), _response(cb)
    {
    }

    virtual void completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::Robot::JsonPrx __proxy = ::Robot::JsonPrx::uncheckedCast(__result->getProxy());
        bool __ret;
        try
        {
            __ret = __proxy->end_Load(__result);
        }
        catch(const ::Ice::Exception& ex)
        {
            ::IceInternal::Callback<T, CT>::exception(__result, ex);
            return;
        }
        if(_response)
        {
            (::IceInternal::Callback<T, CT>::_callback.get()->*_response)(__ret, CT::dynamicCast(__result->getCookie()));
        }
    }

    private:

    Response _response;
};

template<class T, typename CT> Callback_Json_LoadPtr
newCallback_Json_Load(const IceUtil::Handle<T>& instance, void (T::*cb)(bool, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Json_Load<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Json_LoadPtr
newCallback_Json_Load(T* instance, void (T::*cb)(bool, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Json_Load<T, CT>(instance, cb, excb, sentcb);
}

template<class T>
class CallbackNC_Json_CallByName : public Callback_Json_CallByName_Base, public ::IceInternal::OnewayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)();

    CallbackNC_Json_CallByName(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallbackNC<T>(obj, cb, excb, sentcb)
    {
    }
};

template<class T> Callback_Json_CallByNamePtr
newCallback_Json_CallByName(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Json_CallByName<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Json_CallByNamePtr
newCallback_Json_CallByName(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Json_CallByName<T>(instance, 0, excb, sentcb);
}

template<class T> Callback_Json_CallByNamePtr
newCallback_Json_CallByName(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Json_CallByName<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Json_CallByNamePtr
newCallback_Json_CallByName(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Json_CallByName<T>(instance, 0, excb, sentcb);
}

template<class T, typename CT>
class Callback_Json_CallByName : public Callback_Json_CallByName_Base, public ::IceInternal::OnewayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const CT&);

    Callback_Json_CallByName(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallback<T, CT>(obj, cb, excb, sentcb)
    {
    }
};

template<class T, typename CT> Callback_Json_CallByNamePtr
newCallback_Json_CallByName(const IceUtil::Handle<T>& instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Json_CallByName<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Json_CallByNamePtr
newCallback_Json_CallByName(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Json_CallByName<T, CT>(instance, 0, excb, sentcb);
}

template<class T, typename CT> Callback_Json_CallByNamePtr
newCallback_Json_CallByName(T* instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Json_CallByName<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Json_CallByNamePtr
newCallback_Json_CallByName(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Json_CallByName<T, CT>(instance, 0, excb, sentcb);
}

template<class T>
class CallbackNC_Json_CallByClass : public Callback_Json_CallByClass_Base, public ::IceInternal::OnewayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)();

    CallbackNC_Json_CallByClass(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallbackNC<T>(obj, cb, excb, sentcb)
    {
    }
};

template<class T> Callback_Json_CallByClassPtr
newCallback_Json_CallByClass(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Json_CallByClass<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Json_CallByClassPtr
newCallback_Json_CallByClass(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Json_CallByClass<T>(instance, 0, excb, sentcb);
}

template<class T> Callback_Json_CallByClassPtr
newCallback_Json_CallByClass(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Json_CallByClass<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Json_CallByClassPtr
newCallback_Json_CallByClass(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Json_CallByClass<T>(instance, 0, excb, sentcb);
}

template<class T, typename CT>
class Callback_Json_CallByClass : public Callback_Json_CallByClass_Base, public ::IceInternal::OnewayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const CT&);

    Callback_Json_CallByClass(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallback<T, CT>(obj, cb, excb, sentcb)
    {
    }
};

template<class T, typename CT> Callback_Json_CallByClassPtr
newCallback_Json_CallByClass(const IceUtil::Handle<T>& instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Json_CallByClass<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Json_CallByClassPtr
newCallback_Json_CallByClass(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Json_CallByClass<T, CT>(instance, 0, excb, sentcb);
}

template<class T, typename CT> Callback_Json_CallByClassPtr
newCallback_Json_CallByClass(T* instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Json_CallByClass<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Json_CallByClassPtr
newCallback_Json_CallByClass(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Json_CallByClass<T, CT>(instance, 0, excb, sentcb);
}

template<class T>
class CallbackNC_Json_CallByContent : public Callback_Json_CallByContent_Base, public ::IceInternal::OnewayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)();

    CallbackNC_Json_CallByContent(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallbackNC<T>(obj, cb, excb, sentcb)
    {
    }
};

template<class T> Callback_Json_CallByContentPtr
newCallback_Json_CallByContent(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Json_CallByContent<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Json_CallByContentPtr
newCallback_Json_CallByContent(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Json_CallByContent<T>(instance, 0, excb, sentcb);
}

template<class T> Callback_Json_CallByContentPtr
newCallback_Json_CallByContent(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Json_CallByContent<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Json_CallByContentPtr
newCallback_Json_CallByContent(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Json_CallByContent<T>(instance, 0, excb, sentcb);
}

template<class T, typename CT>
class Callback_Json_CallByContent : public Callback_Json_CallByContent_Base, public ::IceInternal::OnewayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const CT&);

    Callback_Json_CallByContent(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallback<T, CT>(obj, cb, excb, sentcb)
    {
    }
};

template<class T, typename CT> Callback_Json_CallByContentPtr
newCallback_Json_CallByContent(const IceUtil::Handle<T>& instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Json_CallByContent<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Json_CallByContentPtr
newCallback_Json_CallByContent(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Json_CallByContent<T, CT>(instance, 0, excb, sentcb);
}

template<class T, typename CT> Callback_Json_CallByContentPtr
newCallback_Json_CallByContent(T* instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Json_CallByContent<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Json_CallByContentPtr
newCallback_Json_CallByContent(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Json_CallByContent<T, CT>(instance, 0, excb, sentcb);
}

template<class T>
class CallbackNC_Json_Stop : public Callback_Json_Stop_Base, public ::IceInternal::OnewayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)();

    CallbackNC_Json_Stop(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallbackNC<T>(obj, cb, excb, sentcb)
    {
    }
};

template<class T> Callback_Json_StopPtr
newCallback_Json_Stop(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Json_Stop<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Json_StopPtr
newCallback_Json_Stop(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Json_Stop<T>(instance, 0, excb, sentcb);
}

template<class T> Callback_Json_StopPtr
newCallback_Json_Stop(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Json_Stop<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Json_StopPtr
newCallback_Json_Stop(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Json_Stop<T>(instance, 0, excb, sentcb);
}

template<class T, typename CT>
class Callback_Json_Stop : public Callback_Json_Stop_Base, public ::IceInternal::OnewayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const CT&);

    Callback_Json_Stop(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallback<T, CT>(obj, cb, excb, sentcb)
    {
    }
};

template<class T, typename CT> Callback_Json_StopPtr
newCallback_Json_Stop(const IceUtil::Handle<T>& instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Json_Stop<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Json_StopPtr
newCallback_Json_Stop(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Json_Stop<T, CT>(instance, 0, excb, sentcb);
}

template<class T, typename CT> Callback_Json_StopPtr
newCallback_Json_Stop(T* instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Json_Stop<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Json_StopPtr
newCallback_Json_Stop(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Json_Stop<T, CT>(instance, 0, excb, sentcb);
}

template<class T>
class CallbackNC_Json_IsPlaying : public Callback_Json_IsPlaying_Base, public ::IceInternal::TwowayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)(bool);

    CallbackNC_Json_IsPlaying(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), _response(cb)
    {
    }

    virtual void completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::Robot::JsonPrx __proxy = ::Robot::JsonPrx::uncheckedCast(__result->getProxy());
        bool __ret;
        try
        {
            __ret = __proxy->end_IsPlaying(__result);
        }
        catch(const ::Ice::Exception& ex)
        {
            ::IceInternal::CallbackNC<T>::exception(__result, ex);
            return;
        }
        if(_response)
        {
            (::IceInternal::CallbackNC<T>::_callback.get()->*_response)(__ret);
        }
    }

    private:

    Response _response;
};

template<class T> Callback_Json_IsPlayingPtr
newCallback_Json_IsPlaying(const IceUtil::Handle<T>& instance, void (T::*cb)(bool), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Json_IsPlaying<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Json_IsPlayingPtr
newCallback_Json_IsPlaying(T* instance, void (T::*cb)(bool), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Json_IsPlaying<T>(instance, cb, excb, sentcb);
}

template<class T, typename CT>
class Callback_Json_IsPlaying : public Callback_Json_IsPlaying_Base, public ::IceInternal::TwowayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(bool, const CT&);

    Callback_Json_IsPlaying(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), _response(cb)
    {
    }

    virtual void completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::Robot::JsonPrx __proxy = ::Robot::JsonPrx::uncheckedCast(__result->getProxy());
        bool __ret;
        try
        {
            __ret = __proxy->end_IsPlaying(__result);
        }
        catch(const ::Ice::Exception& ex)
        {
            ::IceInternal::Callback<T, CT>::exception(__result, ex);
            return;
        }
        if(_response)
        {
            (::IceInternal::Callback<T, CT>::_callback.get()->*_response)(__ret, CT::dynamicCast(__result->getCookie()));
        }
    }

    private:

    Response _response;
};

template<class T, typename CT> Callback_Json_IsPlayingPtr
newCallback_Json_IsPlaying(const IceUtil::Handle<T>& instance, void (T::*cb)(bool, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Json_IsPlaying<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Json_IsPlayingPtr
newCallback_Json_IsPlaying(T* instance, void (T::*cb)(bool, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Json_IsPlaying<T, CT>(instance, cb, excb, sentcb);
}

template<class T>
class CallbackNC_Json_List : public Callback_Json_List_Base, public ::IceInternal::TwowayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)(const ::Ice::StringSeq&);

    CallbackNC_Json_List(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), _response(cb)
    {
    }

    virtual void completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::Robot::JsonPrx __proxy = ::Robot::JsonPrx::uncheckedCast(__result->getProxy());
        ::Ice::StringSeq strList;
        try
        {
            __proxy->end_List(strList, __result);
        }
        catch(const ::Ice::Exception& ex)
        {
            ::IceInternal::CallbackNC<T>::exception(__result, ex);
            return;
        }
        if(_response)
        {
            (::IceInternal::CallbackNC<T>::_callback.get()->*_response)(strList);
        }
    }

    private:

    Response _response;
};

template<class T> Callback_Json_ListPtr
newCallback_Json_List(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::Ice::StringSeq&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Json_List<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Json_ListPtr
newCallback_Json_List(T* instance, void (T::*cb)(const ::Ice::StringSeq&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Json_List<T>(instance, cb, excb, sentcb);
}

template<class T, typename CT>
class Callback_Json_List : public Callback_Json_List_Base, public ::IceInternal::TwowayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const ::Ice::StringSeq&, const CT&);

    Callback_Json_List(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), _response(cb)
    {
    }

    virtual void completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::Robot::JsonPrx __proxy = ::Robot::JsonPrx::uncheckedCast(__result->getProxy());
        ::Ice::StringSeq strList;
        try
        {
            __proxy->end_List(strList, __result);
        }
        catch(const ::Ice::Exception& ex)
        {
            ::IceInternal::Callback<T, CT>::exception(__result, ex);
            return;
        }
        if(_response)
        {
            (::IceInternal::Callback<T, CT>::_callback.get()->*_response)(strList, CT::dynamicCast(__result->getCookie()));
        }
    }

    private:

    Response _response;
};

template<class T, typename CT> Callback_Json_ListPtr
newCallback_Json_List(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::Ice::StringSeq&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Json_List<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Json_ListPtr
newCallback_Json_List(T* instance, void (T::*cb)(const ::Ice::StringSeq&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Json_List<T, CT>(instance, cb, excb, sentcb);
}

template<class T>
class CallbackNC_Motor_SerialWrite : public Callback_Motor_SerialWrite_Base, public ::IceInternal::OnewayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)();

    CallbackNC_Motor_SerialWrite(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallbackNC<T>(obj, cb, excb, sentcb)
    {
    }
};

template<class T> Callback_Motor_SerialWritePtr
newCallback_Motor_SerialWrite(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_SerialWrite<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Motor_SerialWritePtr
newCallback_Motor_SerialWrite(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_SerialWrite<T>(instance, 0, excb, sentcb);
}

template<class T> Callback_Motor_SerialWritePtr
newCallback_Motor_SerialWrite(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_SerialWrite<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Motor_SerialWritePtr
newCallback_Motor_SerialWrite(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_SerialWrite<T>(instance, 0, excb, sentcb);
}

template<class T, typename CT>
class Callback_Motor_SerialWrite : public Callback_Motor_SerialWrite_Base, public ::IceInternal::OnewayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const CT&);

    Callback_Motor_SerialWrite(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallback<T, CT>(obj, cb, excb, sentcb)
    {
    }
};

template<class T, typename CT> Callback_Motor_SerialWritePtr
newCallback_Motor_SerialWrite(const IceUtil::Handle<T>& instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_SerialWrite<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Motor_SerialWritePtr
newCallback_Motor_SerialWrite(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_SerialWrite<T, CT>(instance, 0, excb, sentcb);
}

template<class T, typename CT> Callback_Motor_SerialWritePtr
newCallback_Motor_SerialWrite(T* instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_SerialWrite<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Motor_SerialWritePtr
newCallback_Motor_SerialWrite(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_SerialWrite<T, CT>(instance, 0, excb, sentcb);
}

template<class T>
class CallbackNC_Motor_HeadEnable : public Callback_Motor_HeadEnable_Base, public ::IceInternal::OnewayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)();

    CallbackNC_Motor_HeadEnable(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallbackNC<T>(obj, cb, excb, sentcb)
    {
    }
};

template<class T> Callback_Motor_HeadEnablePtr
newCallback_Motor_HeadEnable(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_HeadEnable<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Motor_HeadEnablePtr
newCallback_Motor_HeadEnable(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_HeadEnable<T>(instance, 0, excb, sentcb);
}

template<class T> Callback_Motor_HeadEnablePtr
newCallback_Motor_HeadEnable(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_HeadEnable<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Motor_HeadEnablePtr
newCallback_Motor_HeadEnable(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_HeadEnable<T>(instance, 0, excb, sentcb);
}

template<class T, typename CT>
class Callback_Motor_HeadEnable : public Callback_Motor_HeadEnable_Base, public ::IceInternal::OnewayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const CT&);

    Callback_Motor_HeadEnable(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallback<T, CT>(obj, cb, excb, sentcb)
    {
    }
};

template<class T, typename CT> Callback_Motor_HeadEnablePtr
newCallback_Motor_HeadEnable(const IceUtil::Handle<T>& instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_HeadEnable<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Motor_HeadEnablePtr
newCallback_Motor_HeadEnable(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_HeadEnable<T, CT>(instance, 0, excb, sentcb);
}

template<class T, typename CT> Callback_Motor_HeadEnablePtr
newCallback_Motor_HeadEnable(T* instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_HeadEnable<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Motor_HeadEnablePtr
newCallback_Motor_HeadEnable(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_HeadEnable<T, CT>(instance, 0, excb, sentcb);
}

template<class T>
class CallbackNC_Motor_HeadLrInit : public Callback_Motor_HeadLrInit_Base, public ::IceInternal::OnewayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)();

    CallbackNC_Motor_HeadLrInit(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallbackNC<T>(obj, cb, excb, sentcb)
    {
    }
};

template<class T> Callback_Motor_HeadLrInitPtr
newCallback_Motor_HeadLrInit(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_HeadLrInit<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Motor_HeadLrInitPtr
newCallback_Motor_HeadLrInit(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_HeadLrInit<T>(instance, 0, excb, sentcb);
}

template<class T> Callback_Motor_HeadLrInitPtr
newCallback_Motor_HeadLrInit(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_HeadLrInit<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Motor_HeadLrInitPtr
newCallback_Motor_HeadLrInit(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_HeadLrInit<T>(instance, 0, excb, sentcb);
}

template<class T, typename CT>
class Callback_Motor_HeadLrInit : public Callback_Motor_HeadLrInit_Base, public ::IceInternal::OnewayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const CT&);

    Callback_Motor_HeadLrInit(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallback<T, CT>(obj, cb, excb, sentcb)
    {
    }
};

template<class T, typename CT> Callback_Motor_HeadLrInitPtr
newCallback_Motor_HeadLrInit(const IceUtil::Handle<T>& instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_HeadLrInit<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Motor_HeadLrInitPtr
newCallback_Motor_HeadLrInit(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_HeadLrInit<T, CT>(instance, 0, excb, sentcb);
}

template<class T, typename CT> Callback_Motor_HeadLrInitPtr
newCallback_Motor_HeadLrInit(T* instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_HeadLrInit<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Motor_HeadLrInitPtr
newCallback_Motor_HeadLrInit(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_HeadLrInit<T, CT>(instance, 0, excb, sentcb);
}

template<class T>
class CallbackNC_Motor_HeadUdInit : public Callback_Motor_HeadUdInit_Base, public ::IceInternal::OnewayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)();

    CallbackNC_Motor_HeadUdInit(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallbackNC<T>(obj, cb, excb, sentcb)
    {
    }
};

template<class T> Callback_Motor_HeadUdInitPtr
newCallback_Motor_HeadUdInit(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_HeadUdInit<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Motor_HeadUdInitPtr
newCallback_Motor_HeadUdInit(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_HeadUdInit<T>(instance, 0, excb, sentcb);
}

template<class T> Callback_Motor_HeadUdInitPtr
newCallback_Motor_HeadUdInit(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_HeadUdInit<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Motor_HeadUdInitPtr
newCallback_Motor_HeadUdInit(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_HeadUdInit<T>(instance, 0, excb, sentcb);
}

template<class T, typename CT>
class Callback_Motor_HeadUdInit : public Callback_Motor_HeadUdInit_Base, public ::IceInternal::OnewayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const CT&);

    Callback_Motor_HeadUdInit(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallback<T, CT>(obj, cb, excb, sentcb)
    {
    }
};

template<class T, typename CT> Callback_Motor_HeadUdInitPtr
newCallback_Motor_HeadUdInit(const IceUtil::Handle<T>& instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_HeadUdInit<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Motor_HeadUdInitPtr
newCallback_Motor_HeadUdInit(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_HeadUdInit<T, CT>(instance, 0, excb, sentcb);
}

template<class T, typename CT> Callback_Motor_HeadUdInitPtr
newCallback_Motor_HeadUdInit(T* instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_HeadUdInit<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Motor_HeadUdInitPtr
newCallback_Motor_HeadUdInit(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_HeadUdInit<T, CT>(instance, 0, excb, sentcb);
}

template<class T>
class CallbackNC_Motor_HeadLrAngle : public Callback_Motor_HeadLrAngle_Base, public ::IceInternal::OnewayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)();

    CallbackNC_Motor_HeadLrAngle(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallbackNC<T>(obj, cb, excb, sentcb)
    {
    }
};

template<class T> Callback_Motor_HeadLrAnglePtr
newCallback_Motor_HeadLrAngle(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_HeadLrAngle<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Motor_HeadLrAnglePtr
newCallback_Motor_HeadLrAngle(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_HeadLrAngle<T>(instance, 0, excb, sentcb);
}

template<class T> Callback_Motor_HeadLrAnglePtr
newCallback_Motor_HeadLrAngle(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_HeadLrAngle<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Motor_HeadLrAnglePtr
newCallback_Motor_HeadLrAngle(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_HeadLrAngle<T>(instance, 0, excb, sentcb);
}

template<class T, typename CT>
class Callback_Motor_HeadLrAngle : public Callback_Motor_HeadLrAngle_Base, public ::IceInternal::OnewayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const CT&);

    Callback_Motor_HeadLrAngle(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallback<T, CT>(obj, cb, excb, sentcb)
    {
    }
};

template<class T, typename CT> Callback_Motor_HeadLrAnglePtr
newCallback_Motor_HeadLrAngle(const IceUtil::Handle<T>& instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_HeadLrAngle<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Motor_HeadLrAnglePtr
newCallback_Motor_HeadLrAngle(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_HeadLrAngle<T, CT>(instance, 0, excb, sentcb);
}

template<class T, typename CT> Callback_Motor_HeadLrAnglePtr
newCallback_Motor_HeadLrAngle(T* instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_HeadLrAngle<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Motor_HeadLrAnglePtr
newCallback_Motor_HeadLrAngle(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_HeadLrAngle<T, CT>(instance, 0, excb, sentcb);
}

template<class T>
class CallbackNC_Motor_HeadUdAngle : public Callback_Motor_HeadUdAngle_Base, public ::IceInternal::OnewayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)();

    CallbackNC_Motor_HeadUdAngle(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallbackNC<T>(obj, cb, excb, sentcb)
    {
    }
};

template<class T> Callback_Motor_HeadUdAnglePtr
newCallback_Motor_HeadUdAngle(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_HeadUdAngle<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Motor_HeadUdAnglePtr
newCallback_Motor_HeadUdAngle(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_HeadUdAngle<T>(instance, 0, excb, sentcb);
}

template<class T> Callback_Motor_HeadUdAnglePtr
newCallback_Motor_HeadUdAngle(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_HeadUdAngle<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Motor_HeadUdAnglePtr
newCallback_Motor_HeadUdAngle(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_HeadUdAngle<T>(instance, 0, excb, sentcb);
}

template<class T, typename CT>
class Callback_Motor_HeadUdAngle : public Callback_Motor_HeadUdAngle_Base, public ::IceInternal::OnewayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const CT&);

    Callback_Motor_HeadUdAngle(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallback<T, CT>(obj, cb, excb, sentcb)
    {
    }
};

template<class T, typename CT> Callback_Motor_HeadUdAnglePtr
newCallback_Motor_HeadUdAngle(const IceUtil::Handle<T>& instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_HeadUdAngle<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Motor_HeadUdAnglePtr
newCallback_Motor_HeadUdAngle(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_HeadUdAngle<T, CT>(instance, 0, excb, sentcb);
}

template<class T, typename CT> Callback_Motor_HeadUdAnglePtr
newCallback_Motor_HeadUdAngle(T* instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_HeadUdAngle<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Motor_HeadUdAnglePtr
newCallback_Motor_HeadUdAngle(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_HeadUdAngle<T, CT>(instance, 0, excb, sentcb);
}

template<class T>
class CallbackNC_Motor_HandLEnable : public Callback_Motor_HandLEnable_Base, public ::IceInternal::OnewayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)();

    CallbackNC_Motor_HandLEnable(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallbackNC<T>(obj, cb, excb, sentcb)
    {
    }
};

template<class T> Callback_Motor_HandLEnablePtr
newCallback_Motor_HandLEnable(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_HandLEnable<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Motor_HandLEnablePtr
newCallback_Motor_HandLEnable(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_HandLEnable<T>(instance, 0, excb, sentcb);
}

template<class T> Callback_Motor_HandLEnablePtr
newCallback_Motor_HandLEnable(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_HandLEnable<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Motor_HandLEnablePtr
newCallback_Motor_HandLEnable(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_HandLEnable<T>(instance, 0, excb, sentcb);
}

template<class T, typename CT>
class Callback_Motor_HandLEnable : public Callback_Motor_HandLEnable_Base, public ::IceInternal::OnewayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const CT&);

    Callback_Motor_HandLEnable(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallback<T, CT>(obj, cb, excb, sentcb)
    {
    }
};

template<class T, typename CT> Callback_Motor_HandLEnablePtr
newCallback_Motor_HandLEnable(const IceUtil::Handle<T>& instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_HandLEnable<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Motor_HandLEnablePtr
newCallback_Motor_HandLEnable(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_HandLEnable<T, CT>(instance, 0, excb, sentcb);
}

template<class T, typename CT> Callback_Motor_HandLEnablePtr
newCallback_Motor_HandLEnable(T* instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_HandLEnable<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Motor_HandLEnablePtr
newCallback_Motor_HandLEnable(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_HandLEnable<T, CT>(instance, 0, excb, sentcb);
}

template<class T>
class CallbackNC_Motor_HandLSwingInit : public Callback_Motor_HandLSwingInit_Base, public ::IceInternal::OnewayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)();

    CallbackNC_Motor_HandLSwingInit(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallbackNC<T>(obj, cb, excb, sentcb)
    {
    }
};

template<class T> Callback_Motor_HandLSwingInitPtr
newCallback_Motor_HandLSwingInit(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_HandLSwingInit<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Motor_HandLSwingInitPtr
newCallback_Motor_HandLSwingInit(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_HandLSwingInit<T>(instance, 0, excb, sentcb);
}

template<class T> Callback_Motor_HandLSwingInitPtr
newCallback_Motor_HandLSwingInit(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_HandLSwingInit<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Motor_HandLSwingInitPtr
newCallback_Motor_HandLSwingInit(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_HandLSwingInit<T>(instance, 0, excb, sentcb);
}

template<class T, typename CT>
class Callback_Motor_HandLSwingInit : public Callback_Motor_HandLSwingInit_Base, public ::IceInternal::OnewayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const CT&);

    Callback_Motor_HandLSwingInit(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallback<T, CT>(obj, cb, excb, sentcb)
    {
    }
};

template<class T, typename CT> Callback_Motor_HandLSwingInitPtr
newCallback_Motor_HandLSwingInit(const IceUtil::Handle<T>& instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_HandLSwingInit<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Motor_HandLSwingInitPtr
newCallback_Motor_HandLSwingInit(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_HandLSwingInit<T, CT>(instance, 0, excb, sentcb);
}

template<class T, typename CT> Callback_Motor_HandLSwingInitPtr
newCallback_Motor_HandLSwingInit(T* instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_HandLSwingInit<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Motor_HandLSwingInitPtr
newCallback_Motor_HandLSwingInit(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_HandLSwingInit<T, CT>(instance, 0, excb, sentcb);
}

template<class T>
class CallbackNC_Motor_HandLExpandInit : public Callback_Motor_HandLExpandInit_Base, public ::IceInternal::OnewayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)();

    CallbackNC_Motor_HandLExpandInit(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallbackNC<T>(obj, cb, excb, sentcb)
    {
    }
};

template<class T> Callback_Motor_HandLExpandInitPtr
newCallback_Motor_HandLExpandInit(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_HandLExpandInit<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Motor_HandLExpandInitPtr
newCallback_Motor_HandLExpandInit(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_HandLExpandInit<T>(instance, 0, excb, sentcb);
}

template<class T> Callback_Motor_HandLExpandInitPtr
newCallback_Motor_HandLExpandInit(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_HandLExpandInit<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Motor_HandLExpandInitPtr
newCallback_Motor_HandLExpandInit(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_HandLExpandInit<T>(instance, 0, excb, sentcb);
}

template<class T, typename CT>
class Callback_Motor_HandLExpandInit : public Callback_Motor_HandLExpandInit_Base, public ::IceInternal::OnewayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const CT&);

    Callback_Motor_HandLExpandInit(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallback<T, CT>(obj, cb, excb, sentcb)
    {
    }
};

template<class T, typename CT> Callback_Motor_HandLExpandInitPtr
newCallback_Motor_HandLExpandInit(const IceUtil::Handle<T>& instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_HandLExpandInit<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Motor_HandLExpandInitPtr
newCallback_Motor_HandLExpandInit(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_HandLExpandInit<T, CT>(instance, 0, excb, sentcb);
}

template<class T, typename CT> Callback_Motor_HandLExpandInitPtr
newCallback_Motor_HandLExpandInit(T* instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_HandLExpandInit<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Motor_HandLExpandInitPtr
newCallback_Motor_HandLExpandInit(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_HandLExpandInit<T, CT>(instance, 0, excb, sentcb);
}

template<class T>
class CallbackNC_Motor_HandLSwingAngle : public Callback_Motor_HandLSwingAngle_Base, public ::IceInternal::OnewayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)();

    CallbackNC_Motor_HandLSwingAngle(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallbackNC<T>(obj, cb, excb, sentcb)
    {
    }
};

template<class T> Callback_Motor_HandLSwingAnglePtr
newCallback_Motor_HandLSwingAngle(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_HandLSwingAngle<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Motor_HandLSwingAnglePtr
newCallback_Motor_HandLSwingAngle(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_HandLSwingAngle<T>(instance, 0, excb, sentcb);
}

template<class T> Callback_Motor_HandLSwingAnglePtr
newCallback_Motor_HandLSwingAngle(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_HandLSwingAngle<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Motor_HandLSwingAnglePtr
newCallback_Motor_HandLSwingAngle(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_HandLSwingAngle<T>(instance, 0, excb, sentcb);
}

template<class T, typename CT>
class Callback_Motor_HandLSwingAngle : public Callback_Motor_HandLSwingAngle_Base, public ::IceInternal::OnewayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const CT&);

    Callback_Motor_HandLSwingAngle(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallback<T, CT>(obj, cb, excb, sentcb)
    {
    }
};

template<class T, typename CT> Callback_Motor_HandLSwingAnglePtr
newCallback_Motor_HandLSwingAngle(const IceUtil::Handle<T>& instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_HandLSwingAngle<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Motor_HandLSwingAnglePtr
newCallback_Motor_HandLSwingAngle(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_HandLSwingAngle<T, CT>(instance, 0, excb, sentcb);
}

template<class T, typename CT> Callback_Motor_HandLSwingAnglePtr
newCallback_Motor_HandLSwingAngle(T* instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_HandLSwingAngle<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Motor_HandLSwingAnglePtr
newCallback_Motor_HandLSwingAngle(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_HandLSwingAngle<T, CT>(instance, 0, excb, sentcb);
}

template<class T>
class CallbackNC_Motor_HandLExpandAngle : public Callback_Motor_HandLExpandAngle_Base, public ::IceInternal::OnewayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)();

    CallbackNC_Motor_HandLExpandAngle(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallbackNC<T>(obj, cb, excb, sentcb)
    {
    }
};

template<class T> Callback_Motor_HandLExpandAnglePtr
newCallback_Motor_HandLExpandAngle(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_HandLExpandAngle<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Motor_HandLExpandAnglePtr
newCallback_Motor_HandLExpandAngle(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_HandLExpandAngle<T>(instance, 0, excb, sentcb);
}

template<class T> Callback_Motor_HandLExpandAnglePtr
newCallback_Motor_HandLExpandAngle(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_HandLExpandAngle<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Motor_HandLExpandAnglePtr
newCallback_Motor_HandLExpandAngle(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_HandLExpandAngle<T>(instance, 0, excb, sentcb);
}

template<class T, typename CT>
class Callback_Motor_HandLExpandAngle : public Callback_Motor_HandLExpandAngle_Base, public ::IceInternal::OnewayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const CT&);

    Callback_Motor_HandLExpandAngle(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallback<T, CT>(obj, cb, excb, sentcb)
    {
    }
};

template<class T, typename CT> Callback_Motor_HandLExpandAnglePtr
newCallback_Motor_HandLExpandAngle(const IceUtil::Handle<T>& instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_HandLExpandAngle<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Motor_HandLExpandAnglePtr
newCallback_Motor_HandLExpandAngle(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_HandLExpandAngle<T, CT>(instance, 0, excb, sentcb);
}

template<class T, typename CT> Callback_Motor_HandLExpandAnglePtr
newCallback_Motor_HandLExpandAngle(T* instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_HandLExpandAngle<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Motor_HandLExpandAnglePtr
newCallback_Motor_HandLExpandAngle(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_HandLExpandAngle<T, CT>(instance, 0, excb, sentcb);
}

template<class T>
class CallbackNC_Motor_HandREnable : public Callback_Motor_HandREnable_Base, public ::IceInternal::OnewayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)();

    CallbackNC_Motor_HandREnable(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallbackNC<T>(obj, cb, excb, sentcb)
    {
    }
};

template<class T> Callback_Motor_HandREnablePtr
newCallback_Motor_HandREnable(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_HandREnable<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Motor_HandREnablePtr
newCallback_Motor_HandREnable(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_HandREnable<T>(instance, 0, excb, sentcb);
}

template<class T> Callback_Motor_HandREnablePtr
newCallback_Motor_HandREnable(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_HandREnable<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Motor_HandREnablePtr
newCallback_Motor_HandREnable(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_HandREnable<T>(instance, 0, excb, sentcb);
}

template<class T, typename CT>
class Callback_Motor_HandREnable : public Callback_Motor_HandREnable_Base, public ::IceInternal::OnewayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const CT&);

    Callback_Motor_HandREnable(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallback<T, CT>(obj, cb, excb, sentcb)
    {
    }
};

template<class T, typename CT> Callback_Motor_HandREnablePtr
newCallback_Motor_HandREnable(const IceUtil::Handle<T>& instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_HandREnable<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Motor_HandREnablePtr
newCallback_Motor_HandREnable(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_HandREnable<T, CT>(instance, 0, excb, sentcb);
}

template<class T, typename CT> Callback_Motor_HandREnablePtr
newCallback_Motor_HandREnable(T* instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_HandREnable<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Motor_HandREnablePtr
newCallback_Motor_HandREnable(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_HandREnable<T, CT>(instance, 0, excb, sentcb);
}

template<class T>
class CallbackNC_Motor_HandRSwingInit : public Callback_Motor_HandRSwingInit_Base, public ::IceInternal::OnewayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)();

    CallbackNC_Motor_HandRSwingInit(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallbackNC<T>(obj, cb, excb, sentcb)
    {
    }
};

template<class T> Callback_Motor_HandRSwingInitPtr
newCallback_Motor_HandRSwingInit(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_HandRSwingInit<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Motor_HandRSwingInitPtr
newCallback_Motor_HandRSwingInit(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_HandRSwingInit<T>(instance, 0, excb, sentcb);
}

template<class T> Callback_Motor_HandRSwingInitPtr
newCallback_Motor_HandRSwingInit(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_HandRSwingInit<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Motor_HandRSwingInitPtr
newCallback_Motor_HandRSwingInit(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_HandRSwingInit<T>(instance, 0, excb, sentcb);
}

template<class T, typename CT>
class Callback_Motor_HandRSwingInit : public Callback_Motor_HandRSwingInit_Base, public ::IceInternal::OnewayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const CT&);

    Callback_Motor_HandRSwingInit(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallback<T, CT>(obj, cb, excb, sentcb)
    {
    }
};

template<class T, typename CT> Callback_Motor_HandRSwingInitPtr
newCallback_Motor_HandRSwingInit(const IceUtil::Handle<T>& instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_HandRSwingInit<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Motor_HandRSwingInitPtr
newCallback_Motor_HandRSwingInit(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_HandRSwingInit<T, CT>(instance, 0, excb, sentcb);
}

template<class T, typename CT> Callback_Motor_HandRSwingInitPtr
newCallback_Motor_HandRSwingInit(T* instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_HandRSwingInit<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Motor_HandRSwingInitPtr
newCallback_Motor_HandRSwingInit(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_HandRSwingInit<T, CT>(instance, 0, excb, sentcb);
}

template<class T>
class CallbackNC_Motor_HandRExpandInit : public Callback_Motor_HandRExpandInit_Base, public ::IceInternal::OnewayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)();

    CallbackNC_Motor_HandRExpandInit(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallbackNC<T>(obj, cb, excb, sentcb)
    {
    }
};

template<class T> Callback_Motor_HandRExpandInitPtr
newCallback_Motor_HandRExpandInit(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_HandRExpandInit<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Motor_HandRExpandInitPtr
newCallback_Motor_HandRExpandInit(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_HandRExpandInit<T>(instance, 0, excb, sentcb);
}

template<class T> Callback_Motor_HandRExpandInitPtr
newCallback_Motor_HandRExpandInit(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_HandRExpandInit<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Motor_HandRExpandInitPtr
newCallback_Motor_HandRExpandInit(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_HandRExpandInit<T>(instance, 0, excb, sentcb);
}

template<class T, typename CT>
class Callback_Motor_HandRExpandInit : public Callback_Motor_HandRExpandInit_Base, public ::IceInternal::OnewayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const CT&);

    Callback_Motor_HandRExpandInit(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallback<T, CT>(obj, cb, excb, sentcb)
    {
    }
};

template<class T, typename CT> Callback_Motor_HandRExpandInitPtr
newCallback_Motor_HandRExpandInit(const IceUtil::Handle<T>& instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_HandRExpandInit<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Motor_HandRExpandInitPtr
newCallback_Motor_HandRExpandInit(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_HandRExpandInit<T, CT>(instance, 0, excb, sentcb);
}

template<class T, typename CT> Callback_Motor_HandRExpandInitPtr
newCallback_Motor_HandRExpandInit(T* instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_HandRExpandInit<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Motor_HandRExpandInitPtr
newCallback_Motor_HandRExpandInit(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_HandRExpandInit<T, CT>(instance, 0, excb, sentcb);
}

template<class T>
class CallbackNC_Motor_HandRSwingAngle : public Callback_Motor_HandRSwingAngle_Base, public ::IceInternal::OnewayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)();

    CallbackNC_Motor_HandRSwingAngle(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallbackNC<T>(obj, cb, excb, sentcb)
    {
    }
};

template<class T> Callback_Motor_HandRSwingAnglePtr
newCallback_Motor_HandRSwingAngle(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_HandRSwingAngle<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Motor_HandRSwingAnglePtr
newCallback_Motor_HandRSwingAngle(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_HandRSwingAngle<T>(instance, 0, excb, sentcb);
}

template<class T> Callback_Motor_HandRSwingAnglePtr
newCallback_Motor_HandRSwingAngle(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_HandRSwingAngle<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Motor_HandRSwingAnglePtr
newCallback_Motor_HandRSwingAngle(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_HandRSwingAngle<T>(instance, 0, excb, sentcb);
}

template<class T, typename CT>
class Callback_Motor_HandRSwingAngle : public Callback_Motor_HandRSwingAngle_Base, public ::IceInternal::OnewayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const CT&);

    Callback_Motor_HandRSwingAngle(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallback<T, CT>(obj, cb, excb, sentcb)
    {
    }
};

template<class T, typename CT> Callback_Motor_HandRSwingAnglePtr
newCallback_Motor_HandRSwingAngle(const IceUtil::Handle<T>& instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_HandRSwingAngle<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Motor_HandRSwingAnglePtr
newCallback_Motor_HandRSwingAngle(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_HandRSwingAngle<T, CT>(instance, 0, excb, sentcb);
}

template<class T, typename CT> Callback_Motor_HandRSwingAnglePtr
newCallback_Motor_HandRSwingAngle(T* instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_HandRSwingAngle<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Motor_HandRSwingAnglePtr
newCallback_Motor_HandRSwingAngle(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_HandRSwingAngle<T, CT>(instance, 0, excb, sentcb);
}

template<class T>
class CallbackNC_Motor_HandRExpandAngle : public Callback_Motor_HandRExpandAngle_Base, public ::IceInternal::OnewayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)();

    CallbackNC_Motor_HandRExpandAngle(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallbackNC<T>(obj, cb, excb, sentcb)
    {
    }
};

template<class T> Callback_Motor_HandRExpandAnglePtr
newCallback_Motor_HandRExpandAngle(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_HandRExpandAngle<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Motor_HandRExpandAnglePtr
newCallback_Motor_HandRExpandAngle(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_HandRExpandAngle<T>(instance, 0, excb, sentcb);
}

template<class T> Callback_Motor_HandRExpandAnglePtr
newCallback_Motor_HandRExpandAngle(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_HandRExpandAngle<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Motor_HandRExpandAnglePtr
newCallback_Motor_HandRExpandAngle(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_HandRExpandAngle<T>(instance, 0, excb, sentcb);
}

template<class T, typename CT>
class Callback_Motor_HandRExpandAngle : public Callback_Motor_HandRExpandAngle_Base, public ::IceInternal::OnewayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const CT&);

    Callback_Motor_HandRExpandAngle(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallback<T, CT>(obj, cb, excb, sentcb)
    {
    }
};

template<class T, typename CT> Callback_Motor_HandRExpandAnglePtr
newCallback_Motor_HandRExpandAngle(const IceUtil::Handle<T>& instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_HandRExpandAngle<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Motor_HandRExpandAnglePtr
newCallback_Motor_HandRExpandAngle(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_HandRExpandAngle<T, CT>(instance, 0, excb, sentcb);
}

template<class T, typename CT> Callback_Motor_HandRExpandAnglePtr
newCallback_Motor_HandRExpandAngle(T* instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_HandRExpandAngle<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Motor_HandRExpandAnglePtr
newCallback_Motor_HandRExpandAngle(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_HandRExpandAngle<T, CT>(instance, 0, excb, sentcb);
}

template<class T>
class CallbackNC_Motor_WheelEnable : public Callback_Motor_WheelEnable_Base, public ::IceInternal::OnewayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)();

    CallbackNC_Motor_WheelEnable(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallbackNC<T>(obj, cb, excb, sentcb)
    {
    }
};

template<class T> Callback_Motor_WheelEnablePtr
newCallback_Motor_WheelEnable(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_WheelEnable<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Motor_WheelEnablePtr
newCallback_Motor_WheelEnable(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_WheelEnable<T>(instance, 0, excb, sentcb);
}

template<class T> Callback_Motor_WheelEnablePtr
newCallback_Motor_WheelEnable(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_WheelEnable<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Motor_WheelEnablePtr
newCallback_Motor_WheelEnable(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_WheelEnable<T>(instance, 0, excb, sentcb);
}

template<class T, typename CT>
class Callback_Motor_WheelEnable : public Callback_Motor_WheelEnable_Base, public ::IceInternal::OnewayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const CT&);

    Callback_Motor_WheelEnable(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallback<T, CT>(obj, cb, excb, sentcb)
    {
    }
};

template<class T, typename CT> Callback_Motor_WheelEnablePtr
newCallback_Motor_WheelEnable(const IceUtil::Handle<T>& instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_WheelEnable<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Motor_WheelEnablePtr
newCallback_Motor_WheelEnable(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_WheelEnable<T, CT>(instance, 0, excb, sentcb);
}

template<class T, typename CT> Callback_Motor_WheelEnablePtr
newCallback_Motor_WheelEnable(T* instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_WheelEnable<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Motor_WheelEnablePtr
newCallback_Motor_WheelEnable(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_WheelEnable<T, CT>(instance, 0, excb, sentcb);
}

template<class T>
class CallbackNC_Motor_WheelStop : public Callback_Motor_WheelStop_Base, public ::IceInternal::OnewayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)();

    CallbackNC_Motor_WheelStop(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallbackNC<T>(obj, cb, excb, sentcb)
    {
    }
};

template<class T> Callback_Motor_WheelStopPtr
newCallback_Motor_WheelStop(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_WheelStop<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Motor_WheelStopPtr
newCallback_Motor_WheelStop(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_WheelStop<T>(instance, 0, excb, sentcb);
}

template<class T> Callback_Motor_WheelStopPtr
newCallback_Motor_WheelStop(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_WheelStop<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Motor_WheelStopPtr
newCallback_Motor_WheelStop(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_WheelStop<T>(instance, 0, excb, sentcb);
}

template<class T, typename CT>
class Callback_Motor_WheelStop : public Callback_Motor_WheelStop_Base, public ::IceInternal::OnewayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const CT&);

    Callback_Motor_WheelStop(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallback<T, CT>(obj, cb, excb, sentcb)
    {
    }
};

template<class T, typename CT> Callback_Motor_WheelStopPtr
newCallback_Motor_WheelStop(const IceUtil::Handle<T>& instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_WheelStop<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Motor_WheelStopPtr
newCallback_Motor_WheelStop(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_WheelStop<T, CT>(instance, 0, excb, sentcb);
}

template<class T, typename CT> Callback_Motor_WheelStopPtr
newCallback_Motor_WheelStop(T* instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_WheelStop<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Motor_WheelStopPtr
newCallback_Motor_WheelStop(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_WheelStop<T, CT>(instance, 0, excb, sentcb);
}

template<class T>
class CallbackNC_Motor_WheelRotate : public Callback_Motor_WheelRotate_Base, public ::IceInternal::OnewayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)();

    CallbackNC_Motor_WheelRotate(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallbackNC<T>(obj, cb, excb, sentcb)
    {
    }
};

template<class T> Callback_Motor_WheelRotatePtr
newCallback_Motor_WheelRotate(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_WheelRotate<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Motor_WheelRotatePtr
newCallback_Motor_WheelRotate(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_WheelRotate<T>(instance, 0, excb, sentcb);
}

template<class T> Callback_Motor_WheelRotatePtr
newCallback_Motor_WheelRotate(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_WheelRotate<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Motor_WheelRotatePtr
newCallback_Motor_WheelRotate(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_WheelRotate<T>(instance, 0, excb, sentcb);
}

template<class T, typename CT>
class Callback_Motor_WheelRotate : public Callback_Motor_WheelRotate_Base, public ::IceInternal::OnewayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const CT&);

    Callback_Motor_WheelRotate(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallback<T, CT>(obj, cb, excb, sentcb)
    {
    }
};

template<class T, typename CT> Callback_Motor_WheelRotatePtr
newCallback_Motor_WheelRotate(const IceUtil::Handle<T>& instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_WheelRotate<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Motor_WheelRotatePtr
newCallback_Motor_WheelRotate(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_WheelRotate<T, CT>(instance, 0, excb, sentcb);
}

template<class T, typename CT> Callback_Motor_WheelRotatePtr
newCallback_Motor_WheelRotate(T* instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_WheelRotate<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Motor_WheelRotatePtr
newCallback_Motor_WheelRotate(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_WheelRotate<T, CT>(instance, 0, excb, sentcb);
}

template<class T>
class CallbackNC_Motor_WheelRun : public Callback_Motor_WheelRun_Base, public ::IceInternal::OnewayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)();

    CallbackNC_Motor_WheelRun(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallbackNC<T>(obj, cb, excb, sentcb)
    {
    }
};

template<class T> Callback_Motor_WheelRunPtr
newCallback_Motor_WheelRun(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_WheelRun<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Motor_WheelRunPtr
newCallback_Motor_WheelRun(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_WheelRun<T>(instance, 0, excb, sentcb);
}

template<class T> Callback_Motor_WheelRunPtr
newCallback_Motor_WheelRun(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_WheelRun<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Motor_WheelRunPtr
newCallback_Motor_WheelRun(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_WheelRun<T>(instance, 0, excb, sentcb);
}

template<class T, typename CT>
class Callback_Motor_WheelRun : public Callback_Motor_WheelRun_Base, public ::IceInternal::OnewayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const CT&);

    Callback_Motor_WheelRun(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallback<T, CT>(obj, cb, excb, sentcb)
    {
    }
};

template<class T, typename CT> Callback_Motor_WheelRunPtr
newCallback_Motor_WheelRun(const IceUtil::Handle<T>& instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_WheelRun<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Motor_WheelRunPtr
newCallback_Motor_WheelRun(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_WheelRun<T, CT>(instance, 0, excb, sentcb);
}

template<class T, typename CT> Callback_Motor_WheelRunPtr
newCallback_Motor_WheelRun(T* instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_WheelRun<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Motor_WheelRunPtr
newCallback_Motor_WheelRun(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_WheelRun<T, CT>(instance, 0, excb, sentcb);
}

template<class T>
class CallbackNC_Motor_WheelRunDiff : public Callback_Motor_WheelRunDiff_Base, public ::IceInternal::OnewayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)();

    CallbackNC_Motor_WheelRunDiff(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallbackNC<T>(obj, cb, excb, sentcb)
    {
    }
};

template<class T> Callback_Motor_WheelRunDiffPtr
newCallback_Motor_WheelRunDiff(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_WheelRunDiff<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Motor_WheelRunDiffPtr
newCallback_Motor_WheelRunDiff(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_WheelRunDiff<T>(instance, 0, excb, sentcb);
}

template<class T> Callback_Motor_WheelRunDiffPtr
newCallback_Motor_WheelRunDiff(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_WheelRunDiff<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Motor_WheelRunDiffPtr
newCallback_Motor_WheelRunDiff(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_WheelRunDiff<T>(instance, 0, excb, sentcb);
}

template<class T, typename CT>
class Callback_Motor_WheelRunDiff : public Callback_Motor_WheelRunDiff_Base, public ::IceInternal::OnewayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const CT&);

    Callback_Motor_WheelRunDiff(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallback<T, CT>(obj, cb, excb, sentcb)
    {
    }
};

template<class T, typename CT> Callback_Motor_WheelRunDiffPtr
newCallback_Motor_WheelRunDiff(const IceUtil::Handle<T>& instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_WheelRunDiff<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Motor_WheelRunDiffPtr
newCallback_Motor_WheelRunDiff(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_WheelRunDiff<T, CT>(instance, 0, excb, sentcb);
}

template<class T, typename CT> Callback_Motor_WheelRunDiffPtr
newCallback_Motor_WheelRunDiff(T* instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_WheelRunDiff<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Motor_WheelRunDiffPtr
newCallback_Motor_WheelRunDiff(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_WheelRunDiff<T, CT>(instance, 0, excb, sentcb);
}

template<class T>
class CallbackNC_Motor_HeadEye : public Callback_Motor_HeadEye_Base, public ::IceInternal::OnewayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)();

    CallbackNC_Motor_HeadEye(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallbackNC<T>(obj, cb, excb, sentcb)
    {
    }
};

template<class T> Callback_Motor_HeadEyePtr
newCallback_Motor_HeadEye(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_HeadEye<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Motor_HeadEyePtr
newCallback_Motor_HeadEye(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_HeadEye<T>(instance, 0, excb, sentcb);
}

template<class T> Callback_Motor_HeadEyePtr
newCallback_Motor_HeadEye(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_HeadEye<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Motor_HeadEyePtr
newCallback_Motor_HeadEye(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_HeadEye<T>(instance, 0, excb, sentcb);
}

template<class T, typename CT>
class Callback_Motor_HeadEye : public Callback_Motor_HeadEye_Base, public ::IceInternal::OnewayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const CT&);

    Callback_Motor_HeadEye(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallback<T, CT>(obj, cb, excb, sentcb)
    {
    }
};

template<class T, typename CT> Callback_Motor_HeadEyePtr
newCallback_Motor_HeadEye(const IceUtil::Handle<T>& instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_HeadEye<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Motor_HeadEyePtr
newCallback_Motor_HeadEye(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_HeadEye<T, CT>(instance, 0, excb, sentcb);
}

template<class T, typename CT> Callback_Motor_HeadEyePtr
newCallback_Motor_HeadEye(T* instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_HeadEye<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Motor_HeadEyePtr
newCallback_Motor_HeadEye(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_HeadEye<T, CT>(instance, 0, excb, sentcb);
}

template<class T>
class CallbackNC_Motor_HeadEye2 : public Callback_Motor_HeadEye2_Base, public ::IceInternal::OnewayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)();

    CallbackNC_Motor_HeadEye2(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallbackNC<T>(obj, cb, excb, sentcb)
    {
    }
};

template<class T> Callback_Motor_HeadEye2Ptr
newCallback_Motor_HeadEye2(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_HeadEye2<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Motor_HeadEye2Ptr
newCallback_Motor_HeadEye2(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_HeadEye2<T>(instance, 0, excb, sentcb);
}

template<class T> Callback_Motor_HeadEye2Ptr
newCallback_Motor_HeadEye2(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_HeadEye2<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Motor_HeadEye2Ptr
newCallback_Motor_HeadEye2(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_HeadEye2<T>(instance, 0, excb, sentcb);
}

template<class T, typename CT>
class Callback_Motor_HeadEye2 : public Callback_Motor_HeadEye2_Base, public ::IceInternal::OnewayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const CT&);

    Callback_Motor_HeadEye2(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallback<T, CT>(obj, cb, excb, sentcb)
    {
    }
};

template<class T, typename CT> Callback_Motor_HeadEye2Ptr
newCallback_Motor_HeadEye2(const IceUtil::Handle<T>& instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_HeadEye2<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Motor_HeadEye2Ptr
newCallback_Motor_HeadEye2(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_HeadEye2<T, CT>(instance, 0, excb, sentcb);
}

template<class T, typename CT> Callback_Motor_HeadEye2Ptr
newCallback_Motor_HeadEye2(T* instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_HeadEye2<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Motor_HeadEye2Ptr
newCallback_Motor_HeadEye2(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_HeadEye2<T, CT>(instance, 0, excb, sentcb);
}

template<class T>
class CallbackNC_Motor_HeadEar : public Callback_Motor_HeadEar_Base, public ::IceInternal::OnewayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)();

    CallbackNC_Motor_HeadEar(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallbackNC<T>(obj, cb, excb, sentcb)
    {
    }
};

template<class T> Callback_Motor_HeadEarPtr
newCallback_Motor_HeadEar(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_HeadEar<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Motor_HeadEarPtr
newCallback_Motor_HeadEar(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_HeadEar<T>(instance, 0, excb, sentcb);
}

template<class T> Callback_Motor_HeadEarPtr
newCallback_Motor_HeadEar(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_HeadEar<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Motor_HeadEarPtr
newCallback_Motor_HeadEar(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_HeadEar<T>(instance, 0, excb, sentcb);
}

template<class T, typename CT>
class Callback_Motor_HeadEar : public Callback_Motor_HeadEar_Base, public ::IceInternal::OnewayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const CT&);

    Callback_Motor_HeadEar(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallback<T, CT>(obj, cb, excb, sentcb)
    {
    }
};

template<class T, typename CT> Callback_Motor_HeadEarPtr
newCallback_Motor_HeadEar(const IceUtil::Handle<T>& instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_HeadEar<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Motor_HeadEarPtr
newCallback_Motor_HeadEar(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_HeadEar<T, CT>(instance, 0, excb, sentcb);
}

template<class T, typename CT> Callback_Motor_HeadEarPtr
newCallback_Motor_HeadEar(T* instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_HeadEar<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Motor_HeadEarPtr
newCallback_Motor_HeadEar(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_HeadEar<T, CT>(instance, 0, excb, sentcb);
}

template<class T>
class CallbackNC_Motor_BodyLed : public Callback_Motor_BodyLed_Base, public ::IceInternal::OnewayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)();

    CallbackNC_Motor_BodyLed(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallbackNC<T>(obj, cb, excb, sentcb)
    {
    }
};

template<class T> Callback_Motor_BodyLedPtr
newCallback_Motor_BodyLed(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_BodyLed<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Motor_BodyLedPtr
newCallback_Motor_BodyLed(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_BodyLed<T>(instance, 0, excb, sentcb);
}

template<class T> Callback_Motor_BodyLedPtr
newCallback_Motor_BodyLed(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_BodyLed<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Motor_BodyLedPtr
newCallback_Motor_BodyLed(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_BodyLed<T>(instance, 0, excb, sentcb);
}

template<class T, typename CT>
class Callback_Motor_BodyLed : public Callback_Motor_BodyLed_Base, public ::IceInternal::OnewayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const CT&);

    Callback_Motor_BodyLed(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallback<T, CT>(obj, cb, excb, sentcb)
    {
    }
};

template<class T, typename CT> Callback_Motor_BodyLedPtr
newCallback_Motor_BodyLed(const IceUtil::Handle<T>& instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_BodyLed<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Motor_BodyLedPtr
newCallback_Motor_BodyLed(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_BodyLed<T, CT>(instance, 0, excb, sentcb);
}

template<class T, typename CT> Callback_Motor_BodyLedPtr
newCallback_Motor_BodyLed(T* instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_BodyLed<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Motor_BodyLedPtr
newCallback_Motor_BodyLed(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_BodyLed<T, CT>(instance, 0, excb, sentcb);
}

template<class T>
class CallbackNC_Motor_TouchSet : public Callback_Motor_TouchSet_Base, public ::IceInternal::OnewayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)();

    CallbackNC_Motor_TouchSet(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallbackNC<T>(obj, cb, excb, sentcb)
    {
    }
};

template<class T> Callback_Motor_TouchSetPtr
newCallback_Motor_TouchSet(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_TouchSet<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Motor_TouchSetPtr
newCallback_Motor_TouchSet(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_TouchSet<T>(instance, 0, excb, sentcb);
}

template<class T> Callback_Motor_TouchSetPtr
newCallback_Motor_TouchSet(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_TouchSet<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Motor_TouchSetPtr
newCallback_Motor_TouchSet(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_TouchSet<T>(instance, 0, excb, sentcb);
}

template<class T, typename CT>
class Callback_Motor_TouchSet : public Callback_Motor_TouchSet_Base, public ::IceInternal::OnewayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const CT&);

    Callback_Motor_TouchSet(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallback<T, CT>(obj, cb, excb, sentcb)
    {
    }
};

template<class T, typename CT> Callback_Motor_TouchSetPtr
newCallback_Motor_TouchSet(const IceUtil::Handle<T>& instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_TouchSet<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Motor_TouchSetPtr
newCallback_Motor_TouchSet(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_TouchSet<T, CT>(instance, 0, excb, sentcb);
}

template<class T, typename CT> Callback_Motor_TouchSetPtr
newCallback_Motor_TouchSet(T* instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_TouchSet<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Motor_TouchSetPtr
newCallback_Motor_TouchSet(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_TouchSet<T, CT>(instance, 0, excb, sentcb);
}

template<class T>
class CallbackNC_Motor_SensorBatteryValue : public Callback_Motor_SensorBatteryValue_Base, public ::IceInternal::TwowayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)(const ::Ice::IntSeq&);

    CallbackNC_Motor_SensorBatteryValue(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), _response(cb)
    {
    }

    virtual void completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::Robot::MotorPrx __proxy = ::Robot::MotorPrx::uncheckedCast(__result->getProxy());
        ::Ice::IntSeq nValList;
        try
        {
            __proxy->end_SensorBatteryValue(nValList, __result);
        }
        catch(const ::Ice::Exception& ex)
        {
            ::IceInternal::CallbackNC<T>::exception(__result, ex);
            return;
        }
        if(_response)
        {
            (::IceInternal::CallbackNC<T>::_callback.get()->*_response)(nValList);
        }
    }

    private:

    Response _response;
};

template<class T> Callback_Motor_SensorBatteryValuePtr
newCallback_Motor_SensorBatteryValue(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::Ice::IntSeq&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_SensorBatteryValue<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Motor_SensorBatteryValuePtr
newCallback_Motor_SensorBatteryValue(T* instance, void (T::*cb)(const ::Ice::IntSeq&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_SensorBatteryValue<T>(instance, cb, excb, sentcb);
}

template<class T, typename CT>
class Callback_Motor_SensorBatteryValue : public Callback_Motor_SensorBatteryValue_Base, public ::IceInternal::TwowayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const ::Ice::IntSeq&, const CT&);

    Callback_Motor_SensorBatteryValue(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), _response(cb)
    {
    }

    virtual void completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::Robot::MotorPrx __proxy = ::Robot::MotorPrx::uncheckedCast(__result->getProxy());
        ::Ice::IntSeq nValList;
        try
        {
            __proxy->end_SensorBatteryValue(nValList, __result);
        }
        catch(const ::Ice::Exception& ex)
        {
            ::IceInternal::Callback<T, CT>::exception(__result, ex);
            return;
        }
        if(_response)
        {
            (::IceInternal::Callback<T, CT>::_callback.get()->*_response)(nValList, CT::dynamicCast(__result->getCookie()));
        }
    }

    private:

    Response _response;
};

template<class T, typename CT> Callback_Motor_SensorBatteryValuePtr
newCallback_Motor_SensorBatteryValue(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::Ice::IntSeq&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_SensorBatteryValue<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Motor_SensorBatteryValuePtr
newCallback_Motor_SensorBatteryValue(T* instance, void (T::*cb)(const ::Ice::IntSeq&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_SensorBatteryValue<T, CT>(instance, cb, excb, sentcb);
}

template<class T>
class CallbackNC_Motor_SensorSonicValue : public Callback_Motor_SensorSonicValue_Base, public ::IceInternal::TwowayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)(const ::Ice::IntSeq&);

    CallbackNC_Motor_SensorSonicValue(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), _response(cb)
    {
    }

    virtual void completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::Robot::MotorPrx __proxy = ::Robot::MotorPrx::uncheckedCast(__result->getProxy());
        ::Ice::IntSeq nValList;
        try
        {
            __proxy->end_SensorSonicValue(nValList, __result);
        }
        catch(const ::Ice::Exception& ex)
        {
            ::IceInternal::CallbackNC<T>::exception(__result, ex);
            return;
        }
        if(_response)
        {
            (::IceInternal::CallbackNC<T>::_callback.get()->*_response)(nValList);
        }
    }

    private:

    Response _response;
};

template<class T> Callback_Motor_SensorSonicValuePtr
newCallback_Motor_SensorSonicValue(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::Ice::IntSeq&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_SensorSonicValue<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Motor_SensorSonicValuePtr
newCallback_Motor_SensorSonicValue(T* instance, void (T::*cb)(const ::Ice::IntSeq&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_SensorSonicValue<T>(instance, cb, excb, sentcb);
}

template<class T, typename CT>
class Callback_Motor_SensorSonicValue : public Callback_Motor_SensorSonicValue_Base, public ::IceInternal::TwowayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const ::Ice::IntSeq&, const CT&);

    Callback_Motor_SensorSonicValue(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), _response(cb)
    {
    }

    virtual void completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::Robot::MotorPrx __proxy = ::Robot::MotorPrx::uncheckedCast(__result->getProxy());
        ::Ice::IntSeq nValList;
        try
        {
            __proxy->end_SensorSonicValue(nValList, __result);
        }
        catch(const ::Ice::Exception& ex)
        {
            ::IceInternal::Callback<T, CT>::exception(__result, ex);
            return;
        }
        if(_response)
        {
            (::IceInternal::Callback<T, CT>::_callback.get()->*_response)(nValList, CT::dynamicCast(__result->getCookie()));
        }
    }

    private:

    Response _response;
};

template<class T, typename CT> Callback_Motor_SensorSonicValuePtr
newCallback_Motor_SensorSonicValue(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::Ice::IntSeq&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_SensorSonicValue<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Motor_SensorSonicValuePtr
newCallback_Motor_SensorSonicValue(T* instance, void (T::*cb)(const ::Ice::IntSeq&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_SensorSonicValue<T, CT>(instance, cb, excb, sentcb);
}

template<class T>
class CallbackNC_Motor_SensorInfraredValue : public Callback_Motor_SensorInfraredValue_Base, public ::IceInternal::TwowayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)(const ::Ice::IntSeq&);

    CallbackNC_Motor_SensorInfraredValue(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), _response(cb)
    {
    }

    virtual void completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::Robot::MotorPrx __proxy = ::Robot::MotorPrx::uncheckedCast(__result->getProxy());
        ::Ice::IntSeq nValList;
        try
        {
            __proxy->end_SensorInfraredValue(nValList, __result);
        }
        catch(const ::Ice::Exception& ex)
        {
            ::IceInternal::CallbackNC<T>::exception(__result, ex);
            return;
        }
        if(_response)
        {
            (::IceInternal::CallbackNC<T>::_callback.get()->*_response)(nValList);
        }
    }

    private:

    Response _response;
};

template<class T> Callback_Motor_SensorInfraredValuePtr
newCallback_Motor_SensorInfraredValue(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::Ice::IntSeq&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_SensorInfraredValue<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Motor_SensorInfraredValuePtr
newCallback_Motor_SensorInfraredValue(T* instance, void (T::*cb)(const ::Ice::IntSeq&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_SensorInfraredValue<T>(instance, cb, excb, sentcb);
}

template<class T, typename CT>
class Callback_Motor_SensorInfraredValue : public Callback_Motor_SensorInfraredValue_Base, public ::IceInternal::TwowayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const ::Ice::IntSeq&, const CT&);

    Callback_Motor_SensorInfraredValue(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), _response(cb)
    {
    }

    virtual void completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::Robot::MotorPrx __proxy = ::Robot::MotorPrx::uncheckedCast(__result->getProxy());
        ::Ice::IntSeq nValList;
        try
        {
            __proxy->end_SensorInfraredValue(nValList, __result);
        }
        catch(const ::Ice::Exception& ex)
        {
            ::IceInternal::Callback<T, CT>::exception(__result, ex);
            return;
        }
        if(_response)
        {
            (::IceInternal::Callback<T, CT>::_callback.get()->*_response)(nValList, CT::dynamicCast(__result->getCookie()));
        }
    }

    private:

    Response _response;
};

template<class T, typename CT> Callback_Motor_SensorInfraredValuePtr
newCallback_Motor_SensorInfraredValue(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::Ice::IntSeq&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_SensorInfraredValue<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Motor_SensorInfraredValuePtr
newCallback_Motor_SensorInfraredValue(T* instance, void (T::*cb)(const ::Ice::IntSeq&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_SensorInfraredValue<T, CT>(instance, cb, excb, sentcb);
}

template<class T>
class CallbackNC_Motor_SetProtect : public Callback_Motor_SetProtect_Base, public ::IceInternal::OnewayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)();

    CallbackNC_Motor_SetProtect(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallbackNC<T>(obj, cb, excb, sentcb)
    {
    }
};

template<class T> Callback_Motor_SetProtectPtr
newCallback_Motor_SetProtect(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_SetProtect<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Motor_SetProtectPtr
newCallback_Motor_SetProtect(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_SetProtect<T>(instance, 0, excb, sentcb);
}

template<class T> Callback_Motor_SetProtectPtr
newCallback_Motor_SetProtect(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_SetProtect<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Motor_SetProtectPtr
newCallback_Motor_SetProtect(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_SetProtect<T>(instance, 0, excb, sentcb);
}

template<class T, typename CT>
class Callback_Motor_SetProtect : public Callback_Motor_SetProtect_Base, public ::IceInternal::OnewayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const CT&);

    Callback_Motor_SetProtect(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallback<T, CT>(obj, cb, excb, sentcb)
    {
    }
};

template<class T, typename CT> Callback_Motor_SetProtectPtr
newCallback_Motor_SetProtect(const IceUtil::Handle<T>& instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_SetProtect<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Motor_SetProtectPtr
newCallback_Motor_SetProtect(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_SetProtect<T, CT>(instance, 0, excb, sentcb);
}

template<class T, typename CT> Callback_Motor_SetProtectPtr
newCallback_Motor_SetProtect(T* instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_SetProtect<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Motor_SetProtectPtr
newCallback_Motor_SetProtect(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_SetProtect<T, CT>(instance, 0, excb, sentcb);
}

template<class T>
class CallbackNC_Motor_GetProtect : public Callback_Motor_GetProtect_Base, public ::IceInternal::TwowayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)(bool);

    CallbackNC_Motor_GetProtect(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), _response(cb)
    {
    }

    virtual void completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::Robot::MotorPrx __proxy = ::Robot::MotorPrx::uncheckedCast(__result->getProxy());
        bool __ret;
        try
        {
            __ret = __proxy->end_GetProtect(__result);
        }
        catch(const ::Ice::Exception& ex)
        {
            ::IceInternal::CallbackNC<T>::exception(__result, ex);
            return;
        }
        if(_response)
        {
            (::IceInternal::CallbackNC<T>::_callback.get()->*_response)(__ret);
        }
    }

    private:

    Response _response;
};

template<class T> Callback_Motor_GetProtectPtr
newCallback_Motor_GetProtect(const IceUtil::Handle<T>& instance, void (T::*cb)(bool), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_GetProtect<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Motor_GetProtectPtr
newCallback_Motor_GetProtect(T* instance, void (T::*cb)(bool), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Motor_GetProtect<T>(instance, cb, excb, sentcb);
}

template<class T, typename CT>
class Callback_Motor_GetProtect : public Callback_Motor_GetProtect_Base, public ::IceInternal::TwowayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(bool, const CT&);

    Callback_Motor_GetProtect(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), _response(cb)
    {
    }

    virtual void completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::Robot::MotorPrx __proxy = ::Robot::MotorPrx::uncheckedCast(__result->getProxy());
        bool __ret;
        try
        {
            __ret = __proxy->end_GetProtect(__result);
        }
        catch(const ::Ice::Exception& ex)
        {
            ::IceInternal::Callback<T, CT>::exception(__result, ex);
            return;
        }
        if(_response)
        {
            (::IceInternal::Callback<T, CT>::_callback.get()->*_response)(__ret, CT::dynamicCast(__result->getCookie()));
        }
    }

    private:

    Response _response;
};

template<class T, typename CT> Callback_Motor_GetProtectPtr
newCallback_Motor_GetProtect(const IceUtil::Handle<T>& instance, void (T::*cb)(bool, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_GetProtect<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Motor_GetProtectPtr
newCallback_Motor_GetProtect(T* instance, void (T::*cb)(bool, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Motor_GetProtect<T, CT>(instance, cb, excb, sentcb);
}

template<class T>
class CallbackNC_Audio_TtsPlayParams : public Callback_Audio_TtsPlayParams_Base, public ::IceInternal::OnewayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)();

    CallbackNC_Audio_TtsPlayParams(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallbackNC<T>(obj, cb, excb, sentcb)
    {
    }
};

template<class T> Callback_Audio_TtsPlayParamsPtr
newCallback_Audio_TtsPlayParams(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Audio_TtsPlayParams<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Audio_TtsPlayParamsPtr
newCallback_Audio_TtsPlayParams(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Audio_TtsPlayParams<T>(instance, 0, excb, sentcb);
}

template<class T> Callback_Audio_TtsPlayParamsPtr
newCallback_Audio_TtsPlayParams(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Audio_TtsPlayParams<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Audio_TtsPlayParamsPtr
newCallback_Audio_TtsPlayParams(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Audio_TtsPlayParams<T>(instance, 0, excb, sentcb);
}

template<class T, typename CT>
class Callback_Audio_TtsPlayParams : public Callback_Audio_TtsPlayParams_Base, public ::IceInternal::OnewayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const CT&);

    Callback_Audio_TtsPlayParams(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallback<T, CT>(obj, cb, excb, sentcb)
    {
    }
};

template<class T, typename CT> Callback_Audio_TtsPlayParamsPtr
newCallback_Audio_TtsPlayParams(const IceUtil::Handle<T>& instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Audio_TtsPlayParams<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Audio_TtsPlayParamsPtr
newCallback_Audio_TtsPlayParams(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Audio_TtsPlayParams<T, CT>(instance, 0, excb, sentcb);
}

template<class T, typename CT> Callback_Audio_TtsPlayParamsPtr
newCallback_Audio_TtsPlayParams(T* instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Audio_TtsPlayParams<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Audio_TtsPlayParamsPtr
newCallback_Audio_TtsPlayParams(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Audio_TtsPlayParams<T, CT>(instance, 0, excb, sentcb);
}

template<class T>
class CallbackNC_Audio_TtsPlay : public Callback_Audio_TtsPlay_Base, public ::IceInternal::OnewayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)();

    CallbackNC_Audio_TtsPlay(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallbackNC<T>(obj, cb, excb, sentcb)
    {
    }
};

template<class T> Callback_Audio_TtsPlayPtr
newCallback_Audio_TtsPlay(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Audio_TtsPlay<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Audio_TtsPlayPtr
newCallback_Audio_TtsPlay(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Audio_TtsPlay<T>(instance, 0, excb, sentcb);
}

template<class T> Callback_Audio_TtsPlayPtr
newCallback_Audio_TtsPlay(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Audio_TtsPlay<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Audio_TtsPlayPtr
newCallback_Audio_TtsPlay(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Audio_TtsPlay<T>(instance, 0, excb, sentcb);
}

template<class T, typename CT>
class Callback_Audio_TtsPlay : public Callback_Audio_TtsPlay_Base, public ::IceInternal::OnewayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const CT&);

    Callback_Audio_TtsPlay(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallback<T, CT>(obj, cb, excb, sentcb)
    {
    }
};

template<class T, typename CT> Callback_Audio_TtsPlayPtr
newCallback_Audio_TtsPlay(const IceUtil::Handle<T>& instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Audio_TtsPlay<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Audio_TtsPlayPtr
newCallback_Audio_TtsPlay(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Audio_TtsPlay<T, CT>(instance, 0, excb, sentcb);
}

template<class T, typename CT> Callback_Audio_TtsPlayPtr
newCallback_Audio_TtsPlay(T* instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Audio_TtsPlay<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Audio_TtsPlayPtr
newCallback_Audio_TtsPlay(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Audio_TtsPlay<T, CT>(instance, 0, excb, sentcb);
}

template<class T>
class CallbackNC_Audio_TtsPlayFile : public Callback_Audio_TtsPlayFile_Base, public ::IceInternal::OnewayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)();

    CallbackNC_Audio_TtsPlayFile(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallbackNC<T>(obj, cb, excb, sentcb)
    {
    }
};

template<class T> Callback_Audio_TtsPlayFilePtr
newCallback_Audio_TtsPlayFile(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Audio_TtsPlayFile<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Audio_TtsPlayFilePtr
newCallback_Audio_TtsPlayFile(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Audio_TtsPlayFile<T>(instance, 0, excb, sentcb);
}

template<class T> Callback_Audio_TtsPlayFilePtr
newCallback_Audio_TtsPlayFile(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Audio_TtsPlayFile<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Audio_TtsPlayFilePtr
newCallback_Audio_TtsPlayFile(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Audio_TtsPlayFile<T>(instance, 0, excb, sentcb);
}

template<class T, typename CT>
class Callback_Audio_TtsPlayFile : public Callback_Audio_TtsPlayFile_Base, public ::IceInternal::OnewayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const CT&);

    Callback_Audio_TtsPlayFile(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallback<T, CT>(obj, cb, excb, sentcb)
    {
    }
};

template<class T, typename CT> Callback_Audio_TtsPlayFilePtr
newCallback_Audio_TtsPlayFile(const IceUtil::Handle<T>& instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Audio_TtsPlayFile<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Audio_TtsPlayFilePtr
newCallback_Audio_TtsPlayFile(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Audio_TtsPlayFile<T, CT>(instance, 0, excb, sentcb);
}

template<class T, typename CT> Callback_Audio_TtsPlayFilePtr
newCallback_Audio_TtsPlayFile(T* instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Audio_TtsPlayFile<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Audio_TtsPlayFilePtr
newCallback_Audio_TtsPlayFile(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Audio_TtsPlayFile<T, CT>(instance, 0, excb, sentcb);
}

template<class T>
class CallbackNC_Audio_TtsSetVolume : public Callback_Audio_TtsSetVolume_Base, public ::IceInternal::OnewayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)();

    CallbackNC_Audio_TtsSetVolume(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallbackNC<T>(obj, cb, excb, sentcb)
    {
    }
};

template<class T> Callback_Audio_TtsSetVolumePtr
newCallback_Audio_TtsSetVolume(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Audio_TtsSetVolume<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Audio_TtsSetVolumePtr
newCallback_Audio_TtsSetVolume(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Audio_TtsSetVolume<T>(instance, 0, excb, sentcb);
}

template<class T> Callback_Audio_TtsSetVolumePtr
newCallback_Audio_TtsSetVolume(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Audio_TtsSetVolume<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Audio_TtsSetVolumePtr
newCallback_Audio_TtsSetVolume(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Audio_TtsSetVolume<T>(instance, 0, excb, sentcb);
}

template<class T, typename CT>
class Callback_Audio_TtsSetVolume : public Callback_Audio_TtsSetVolume_Base, public ::IceInternal::OnewayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const CT&);

    Callback_Audio_TtsSetVolume(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallback<T, CT>(obj, cb, excb, sentcb)
    {
    }
};

template<class T, typename CT> Callback_Audio_TtsSetVolumePtr
newCallback_Audio_TtsSetVolume(const IceUtil::Handle<T>& instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Audio_TtsSetVolume<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Audio_TtsSetVolumePtr
newCallback_Audio_TtsSetVolume(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Audio_TtsSetVolume<T, CT>(instance, 0, excb, sentcb);
}

template<class T, typename CT> Callback_Audio_TtsSetVolumePtr
newCallback_Audio_TtsSetVolume(T* instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Audio_TtsSetVolume<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Audio_TtsSetVolumePtr
newCallback_Audio_TtsSetVolume(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Audio_TtsSetVolume<T, CT>(instance, 0, excb, sentcb);
}

template<class T>
class CallbackNC_Audio_TtsStop : public Callback_Audio_TtsStop_Base, public ::IceInternal::OnewayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)();

    CallbackNC_Audio_TtsStop(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallbackNC<T>(obj, cb, excb, sentcb)
    {
    }
};

template<class T> Callback_Audio_TtsStopPtr
newCallback_Audio_TtsStop(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Audio_TtsStop<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Audio_TtsStopPtr
newCallback_Audio_TtsStop(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Audio_TtsStop<T>(instance, 0, excb, sentcb);
}

template<class T> Callback_Audio_TtsStopPtr
newCallback_Audio_TtsStop(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Audio_TtsStop<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Audio_TtsStopPtr
newCallback_Audio_TtsStop(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Audio_TtsStop<T>(instance, 0, excb, sentcb);
}

template<class T, typename CT>
class Callback_Audio_TtsStop : public Callback_Audio_TtsStop_Base, public ::IceInternal::OnewayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const CT&);

    Callback_Audio_TtsStop(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallback<T, CT>(obj, cb, excb, sentcb)
    {
    }
};

template<class T, typename CT> Callback_Audio_TtsStopPtr
newCallback_Audio_TtsStop(const IceUtil::Handle<T>& instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Audio_TtsStop<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Audio_TtsStopPtr
newCallback_Audio_TtsStop(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Audio_TtsStop<T, CT>(instance, 0, excb, sentcb);
}

template<class T, typename CT> Callback_Audio_TtsStopPtr
newCallback_Audio_TtsStop(T* instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Audio_TtsStop<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Audio_TtsStopPtr
newCallback_Audio_TtsStop(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Audio_TtsStop<T, CT>(instance, 0, excb, sentcb);
}

template<class T>
class CallbackNC_Audio_TtsIsPlaying : public Callback_Audio_TtsIsPlaying_Base, public ::IceInternal::TwowayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)(bool);

    CallbackNC_Audio_TtsIsPlaying(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), _response(cb)
    {
    }

    virtual void completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::Robot::AudioPrx __proxy = ::Robot::AudioPrx::uncheckedCast(__result->getProxy());
        bool __ret;
        try
        {
            __ret = __proxy->end_TtsIsPlaying(__result);
        }
        catch(const ::Ice::Exception& ex)
        {
            ::IceInternal::CallbackNC<T>::exception(__result, ex);
            return;
        }
        if(_response)
        {
            (::IceInternal::CallbackNC<T>::_callback.get()->*_response)(__ret);
        }
    }

    private:

    Response _response;
};

template<class T> Callback_Audio_TtsIsPlayingPtr
newCallback_Audio_TtsIsPlaying(const IceUtil::Handle<T>& instance, void (T::*cb)(bool), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Audio_TtsIsPlaying<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Audio_TtsIsPlayingPtr
newCallback_Audio_TtsIsPlaying(T* instance, void (T::*cb)(bool), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Audio_TtsIsPlaying<T>(instance, cb, excb, sentcb);
}

template<class T, typename CT>
class Callback_Audio_TtsIsPlaying : public Callback_Audio_TtsIsPlaying_Base, public ::IceInternal::TwowayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(bool, const CT&);

    Callback_Audio_TtsIsPlaying(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), _response(cb)
    {
    }

    virtual void completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::Robot::AudioPrx __proxy = ::Robot::AudioPrx::uncheckedCast(__result->getProxy());
        bool __ret;
        try
        {
            __ret = __proxy->end_TtsIsPlaying(__result);
        }
        catch(const ::Ice::Exception& ex)
        {
            ::IceInternal::Callback<T, CT>::exception(__result, ex);
            return;
        }
        if(_response)
        {
            (::IceInternal::Callback<T, CT>::_callback.get()->*_response)(__ret, CT::dynamicCast(__result->getCookie()));
        }
    }

    private:

    Response _response;
};

template<class T, typename CT> Callback_Audio_TtsIsPlayingPtr
newCallback_Audio_TtsIsPlaying(const IceUtil::Handle<T>& instance, void (T::*cb)(bool, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Audio_TtsIsPlaying<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Audio_TtsIsPlayingPtr
newCallback_Audio_TtsIsPlaying(T* instance, void (T::*cb)(bool, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Audio_TtsIsPlaying<T, CT>(instance, cb, excb, sentcb);
}

template<class T>
class CallbackNC_Audio_AsrBuildCmd : public Callback_Audio_AsrBuildCmd_Base, public ::IceInternal::OnewayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)();

    CallbackNC_Audio_AsrBuildCmd(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallbackNC<T>(obj, cb, excb, sentcb)
    {
    }
};

template<class T> Callback_Audio_AsrBuildCmdPtr
newCallback_Audio_AsrBuildCmd(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Audio_AsrBuildCmd<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Audio_AsrBuildCmdPtr
newCallback_Audio_AsrBuildCmd(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Audio_AsrBuildCmd<T>(instance, 0, excb, sentcb);
}

template<class T> Callback_Audio_AsrBuildCmdPtr
newCallback_Audio_AsrBuildCmd(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Audio_AsrBuildCmd<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Audio_AsrBuildCmdPtr
newCallback_Audio_AsrBuildCmd(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Audio_AsrBuildCmd<T>(instance, 0, excb, sentcb);
}

template<class T, typename CT>
class Callback_Audio_AsrBuildCmd : public Callback_Audio_AsrBuildCmd_Base, public ::IceInternal::OnewayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const CT&);

    Callback_Audio_AsrBuildCmd(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallback<T, CT>(obj, cb, excb, sentcb)
    {
    }
};

template<class T, typename CT> Callback_Audio_AsrBuildCmdPtr
newCallback_Audio_AsrBuildCmd(const IceUtil::Handle<T>& instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Audio_AsrBuildCmd<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Audio_AsrBuildCmdPtr
newCallback_Audio_AsrBuildCmd(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Audio_AsrBuildCmd<T, CT>(instance, 0, excb, sentcb);
}

template<class T, typename CT> Callback_Audio_AsrBuildCmdPtr
newCallback_Audio_AsrBuildCmd(T* instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Audio_AsrBuildCmd<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Audio_AsrBuildCmdPtr
newCallback_Audio_AsrBuildCmd(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Audio_AsrBuildCmd<T, CT>(instance, 0, excb, sentcb);
}

template<class T>
class CallbackNC_Audio_AsrStart : public Callback_Audio_AsrStart_Base, public ::IceInternal::OnewayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)();

    CallbackNC_Audio_AsrStart(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallbackNC<T>(obj, cb, excb, sentcb)
    {
    }
};

template<class T> Callback_Audio_AsrStartPtr
newCallback_Audio_AsrStart(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Audio_AsrStart<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Audio_AsrStartPtr
newCallback_Audio_AsrStart(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Audio_AsrStart<T>(instance, 0, excb, sentcb);
}

template<class T> Callback_Audio_AsrStartPtr
newCallback_Audio_AsrStart(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Audio_AsrStart<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Audio_AsrStartPtr
newCallback_Audio_AsrStart(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Audio_AsrStart<T>(instance, 0, excb, sentcb);
}

template<class T, typename CT>
class Callback_Audio_AsrStart : public Callback_Audio_AsrStart_Base, public ::IceInternal::OnewayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const CT&);

    Callback_Audio_AsrStart(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallback<T, CT>(obj, cb, excb, sentcb)
    {
    }
};

template<class T, typename CT> Callback_Audio_AsrStartPtr
newCallback_Audio_AsrStart(const IceUtil::Handle<T>& instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Audio_AsrStart<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Audio_AsrStartPtr
newCallback_Audio_AsrStart(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Audio_AsrStart<T, CT>(instance, 0, excb, sentcb);
}

template<class T, typename CT> Callback_Audio_AsrStartPtr
newCallback_Audio_AsrStart(T* instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Audio_AsrStart<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Audio_AsrStartPtr
newCallback_Audio_AsrStart(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Audio_AsrStart<T, CT>(instance, 0, excb, sentcb);
}

template<class T>
class CallbackNC_Audio_AsrStop : public Callback_Audio_AsrStop_Base, public ::IceInternal::OnewayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)();

    CallbackNC_Audio_AsrStop(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallbackNC<T>(obj, cb, excb, sentcb)
    {
    }
};

template<class T> Callback_Audio_AsrStopPtr
newCallback_Audio_AsrStop(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Audio_AsrStop<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Audio_AsrStopPtr
newCallback_Audio_AsrStop(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Audio_AsrStop<T>(instance, 0, excb, sentcb);
}

template<class T> Callback_Audio_AsrStopPtr
newCallback_Audio_AsrStop(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Audio_AsrStop<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Audio_AsrStopPtr
newCallback_Audio_AsrStop(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Audio_AsrStop<T>(instance, 0, excb, sentcb);
}

template<class T, typename CT>
class Callback_Audio_AsrStop : public Callback_Audio_AsrStop_Base, public ::IceInternal::OnewayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const CT&);

    Callback_Audio_AsrStop(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallback<T, CT>(obj, cb, excb, sentcb)
    {
    }
};

template<class T, typename CT> Callback_Audio_AsrStopPtr
newCallback_Audio_AsrStop(const IceUtil::Handle<T>& instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Audio_AsrStop<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Audio_AsrStopPtr
newCallback_Audio_AsrStop(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Audio_AsrStop<T, CT>(instance, 0, excb, sentcb);
}

template<class T, typename CT> Callback_Audio_AsrStopPtr
newCallback_Audio_AsrStop(T* instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Audio_AsrStop<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Audio_AsrStopPtr
newCallback_Audio_AsrStop(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Audio_AsrStop<T, CT>(instance, 0, excb, sentcb);
}

template<class T>
class CallbackNC_Audio_MediaPlay : public Callback_Audio_MediaPlay_Base, public ::IceInternal::OnewayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)();

    CallbackNC_Audio_MediaPlay(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallbackNC<T>(obj, cb, excb, sentcb)
    {
    }
};

template<class T> Callback_Audio_MediaPlayPtr
newCallback_Audio_MediaPlay(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Audio_MediaPlay<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Audio_MediaPlayPtr
newCallback_Audio_MediaPlay(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Audio_MediaPlay<T>(instance, 0, excb, sentcb);
}

template<class T> Callback_Audio_MediaPlayPtr
newCallback_Audio_MediaPlay(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Audio_MediaPlay<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Audio_MediaPlayPtr
newCallback_Audio_MediaPlay(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Audio_MediaPlay<T>(instance, 0, excb, sentcb);
}

template<class T, typename CT>
class Callback_Audio_MediaPlay : public Callback_Audio_MediaPlay_Base, public ::IceInternal::OnewayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const CT&);

    Callback_Audio_MediaPlay(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallback<T, CT>(obj, cb, excb, sentcb)
    {
    }
};

template<class T, typename CT> Callback_Audio_MediaPlayPtr
newCallback_Audio_MediaPlay(const IceUtil::Handle<T>& instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Audio_MediaPlay<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Audio_MediaPlayPtr
newCallback_Audio_MediaPlay(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Audio_MediaPlay<T, CT>(instance, 0, excb, sentcb);
}

template<class T, typename CT> Callback_Audio_MediaPlayPtr
newCallback_Audio_MediaPlay(T* instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Audio_MediaPlay<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Audio_MediaPlayPtr
newCallback_Audio_MediaPlay(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Audio_MediaPlay<T, CT>(instance, 0, excb, sentcb);
}

template<class T>
class CallbackNC_Audio_MediaSetVolume : public Callback_Audio_MediaSetVolume_Base, public ::IceInternal::OnewayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)();

    CallbackNC_Audio_MediaSetVolume(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallbackNC<T>(obj, cb, excb, sentcb)
    {
    }
};

template<class T> Callback_Audio_MediaSetVolumePtr
newCallback_Audio_MediaSetVolume(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Audio_MediaSetVolume<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Audio_MediaSetVolumePtr
newCallback_Audio_MediaSetVolume(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Audio_MediaSetVolume<T>(instance, 0, excb, sentcb);
}

template<class T> Callback_Audio_MediaSetVolumePtr
newCallback_Audio_MediaSetVolume(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Audio_MediaSetVolume<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Audio_MediaSetVolumePtr
newCallback_Audio_MediaSetVolume(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Audio_MediaSetVolume<T>(instance, 0, excb, sentcb);
}

template<class T, typename CT>
class Callback_Audio_MediaSetVolume : public Callback_Audio_MediaSetVolume_Base, public ::IceInternal::OnewayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const CT&);

    Callback_Audio_MediaSetVolume(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallback<T, CT>(obj, cb, excb, sentcb)
    {
    }
};

template<class T, typename CT> Callback_Audio_MediaSetVolumePtr
newCallback_Audio_MediaSetVolume(const IceUtil::Handle<T>& instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Audio_MediaSetVolume<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Audio_MediaSetVolumePtr
newCallback_Audio_MediaSetVolume(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Audio_MediaSetVolume<T, CT>(instance, 0, excb, sentcb);
}

template<class T, typename CT> Callback_Audio_MediaSetVolumePtr
newCallback_Audio_MediaSetVolume(T* instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Audio_MediaSetVolume<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Audio_MediaSetVolumePtr
newCallback_Audio_MediaSetVolume(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Audio_MediaSetVolume<T, CT>(instance, 0, excb, sentcb);
}

template<class T>
class CallbackNC_Audio_MediaStop : public Callback_Audio_MediaStop_Base, public ::IceInternal::OnewayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)();

    CallbackNC_Audio_MediaStop(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallbackNC<T>(obj, cb, excb, sentcb)
    {
    }
};

template<class T> Callback_Audio_MediaStopPtr
newCallback_Audio_MediaStop(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Audio_MediaStop<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Audio_MediaStopPtr
newCallback_Audio_MediaStop(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Audio_MediaStop<T>(instance, 0, excb, sentcb);
}

template<class T> Callback_Audio_MediaStopPtr
newCallback_Audio_MediaStop(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Audio_MediaStop<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Audio_MediaStopPtr
newCallback_Audio_MediaStop(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Audio_MediaStop<T>(instance, 0, excb, sentcb);
}

template<class T, typename CT>
class Callback_Audio_MediaStop : public Callback_Audio_MediaStop_Base, public ::IceInternal::OnewayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const CT&);

    Callback_Audio_MediaStop(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallback<T, CT>(obj, cb, excb, sentcb)
    {
    }
};

template<class T, typename CT> Callback_Audio_MediaStopPtr
newCallback_Audio_MediaStop(const IceUtil::Handle<T>& instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Audio_MediaStop<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Audio_MediaStopPtr
newCallback_Audio_MediaStop(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Audio_MediaStop<T, CT>(instance, 0, excb, sentcb);
}

template<class T, typename CT> Callback_Audio_MediaStopPtr
newCallback_Audio_MediaStop(T* instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Audio_MediaStop<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Audio_MediaStopPtr
newCallback_Audio_MediaStop(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Audio_MediaStop<T, CT>(instance, 0, excb, sentcb);
}

template<class T>
class CallbackNC_Audio_MediaIsPlaying : public Callback_Audio_MediaIsPlaying_Base, public ::IceInternal::TwowayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)(bool);

    CallbackNC_Audio_MediaIsPlaying(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), _response(cb)
    {
    }

    virtual void completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::Robot::AudioPrx __proxy = ::Robot::AudioPrx::uncheckedCast(__result->getProxy());
        bool __ret;
        try
        {
            __ret = __proxy->end_MediaIsPlaying(__result);
        }
        catch(const ::Ice::Exception& ex)
        {
            ::IceInternal::CallbackNC<T>::exception(__result, ex);
            return;
        }
        if(_response)
        {
            (::IceInternal::CallbackNC<T>::_callback.get()->*_response)(__ret);
        }
    }

    private:

    Response _response;
};

template<class T> Callback_Audio_MediaIsPlayingPtr
newCallback_Audio_MediaIsPlaying(const IceUtil::Handle<T>& instance, void (T::*cb)(bool), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Audio_MediaIsPlaying<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Audio_MediaIsPlayingPtr
newCallback_Audio_MediaIsPlaying(T* instance, void (T::*cb)(bool), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Audio_MediaIsPlaying<T>(instance, cb, excb, sentcb);
}

template<class T, typename CT>
class Callback_Audio_MediaIsPlaying : public Callback_Audio_MediaIsPlaying_Base, public ::IceInternal::TwowayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(bool, const CT&);

    Callback_Audio_MediaIsPlaying(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), _response(cb)
    {
    }

    virtual void completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::Robot::AudioPrx __proxy = ::Robot::AudioPrx::uncheckedCast(__result->getProxy());
        bool __ret;
        try
        {
            __ret = __proxy->end_MediaIsPlaying(__result);
        }
        catch(const ::Ice::Exception& ex)
        {
            ::IceInternal::Callback<T, CT>::exception(__result, ex);
            return;
        }
        if(_response)
        {
            (::IceInternal::Callback<T, CT>::_callback.get()->*_response)(__ret, CT::dynamicCast(__result->getCookie()));
        }
    }

    private:

    Response _response;
};

template<class T, typename CT> Callback_Audio_MediaIsPlayingPtr
newCallback_Audio_MediaIsPlaying(const IceUtil::Handle<T>& instance, void (T::*cb)(bool, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Audio_MediaIsPlaying<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Audio_MediaIsPlayingPtr
newCallback_Audio_MediaIsPlaying(T* instance, void (T::*cb)(bool, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Audio_MediaIsPlaying<T, CT>(instance, cb, excb, sentcb);
}

template<class T>
class CallbackNC_ScreenEx_ShowRepeatDir : public Callback_ScreenEx_ShowRepeatDir_Base, public ::IceInternal::OnewayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)();

    CallbackNC_ScreenEx_ShowRepeatDir(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallbackNC<T>(obj, cb, excb, sentcb)
    {
    }
};

template<class T> Callback_ScreenEx_ShowRepeatDirPtr
newCallback_ScreenEx_ShowRepeatDir(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_ScreenEx_ShowRepeatDir<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_ScreenEx_ShowRepeatDirPtr
newCallback_ScreenEx_ShowRepeatDir(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_ScreenEx_ShowRepeatDir<T>(instance, 0, excb, sentcb);
}

template<class T> Callback_ScreenEx_ShowRepeatDirPtr
newCallback_ScreenEx_ShowRepeatDir(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_ScreenEx_ShowRepeatDir<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_ScreenEx_ShowRepeatDirPtr
newCallback_ScreenEx_ShowRepeatDir(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_ScreenEx_ShowRepeatDir<T>(instance, 0, excb, sentcb);
}

template<class T, typename CT>
class Callback_ScreenEx_ShowRepeatDir : public Callback_ScreenEx_ShowRepeatDir_Base, public ::IceInternal::OnewayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const CT&);

    Callback_ScreenEx_ShowRepeatDir(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallback<T, CT>(obj, cb, excb, sentcb)
    {
    }
};

template<class T, typename CT> Callback_ScreenEx_ShowRepeatDirPtr
newCallback_ScreenEx_ShowRepeatDir(const IceUtil::Handle<T>& instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_ScreenEx_ShowRepeatDir<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_ScreenEx_ShowRepeatDirPtr
newCallback_ScreenEx_ShowRepeatDir(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_ScreenEx_ShowRepeatDir<T, CT>(instance, 0, excb, sentcb);
}

template<class T, typename CT> Callback_ScreenEx_ShowRepeatDirPtr
newCallback_ScreenEx_ShowRepeatDir(T* instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_ScreenEx_ShowRepeatDir<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_ScreenEx_ShowRepeatDirPtr
newCallback_ScreenEx_ShowRepeatDir(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_ScreenEx_ShowRepeatDir<T, CT>(instance, 0, excb, sentcb);
}

template<class T>
class CallbackNC_ScreenEx_ShowPic : public Callback_ScreenEx_ShowPic_Base, public ::IceInternal::OnewayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)();

    CallbackNC_ScreenEx_ShowPic(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallbackNC<T>(obj, cb, excb, sentcb)
    {
    }
};

template<class T> Callback_ScreenEx_ShowPicPtr
newCallback_ScreenEx_ShowPic(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_ScreenEx_ShowPic<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_ScreenEx_ShowPicPtr
newCallback_ScreenEx_ShowPic(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_ScreenEx_ShowPic<T>(instance, 0, excb, sentcb);
}

template<class T> Callback_ScreenEx_ShowPicPtr
newCallback_ScreenEx_ShowPic(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_ScreenEx_ShowPic<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_ScreenEx_ShowPicPtr
newCallback_ScreenEx_ShowPic(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_ScreenEx_ShowPic<T>(instance, 0, excb, sentcb);
}

template<class T, typename CT>
class Callback_ScreenEx_ShowPic : public Callback_ScreenEx_ShowPic_Base, public ::IceInternal::OnewayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const CT&);

    Callback_ScreenEx_ShowPic(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallback<T, CT>(obj, cb, excb, sentcb)
    {
    }
};

template<class T, typename CT> Callback_ScreenEx_ShowPicPtr
newCallback_ScreenEx_ShowPic(const IceUtil::Handle<T>& instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_ScreenEx_ShowPic<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_ScreenEx_ShowPicPtr
newCallback_ScreenEx_ShowPic(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_ScreenEx_ShowPic<T, CT>(instance, 0, excb, sentcb);
}

template<class T, typename CT> Callback_ScreenEx_ShowPicPtr
newCallback_ScreenEx_ShowPic(T* instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_ScreenEx_ShowPic<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_ScreenEx_ShowPicPtr
newCallback_ScreenEx_ShowPic(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_ScreenEx_ShowPic<T, CT>(instance, 0, excb, sentcb);
}

template<class T>
class CallbackNC_ScreenEx_ShowVideo : public Callback_ScreenEx_ShowVideo_Base, public ::IceInternal::OnewayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)();

    CallbackNC_ScreenEx_ShowVideo(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallbackNC<T>(obj, cb, excb, sentcb)
    {
    }
};

template<class T> Callback_ScreenEx_ShowVideoPtr
newCallback_ScreenEx_ShowVideo(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_ScreenEx_ShowVideo<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_ScreenEx_ShowVideoPtr
newCallback_ScreenEx_ShowVideo(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_ScreenEx_ShowVideo<T>(instance, 0, excb, sentcb);
}

template<class T> Callback_ScreenEx_ShowVideoPtr
newCallback_ScreenEx_ShowVideo(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_ScreenEx_ShowVideo<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_ScreenEx_ShowVideoPtr
newCallback_ScreenEx_ShowVideo(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_ScreenEx_ShowVideo<T>(instance, 0, excb, sentcb);
}

template<class T, typename CT>
class Callback_ScreenEx_ShowVideo : public Callback_ScreenEx_ShowVideo_Base, public ::IceInternal::OnewayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const CT&);

    Callback_ScreenEx_ShowVideo(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallback<T, CT>(obj, cb, excb, sentcb)
    {
    }
};

template<class T, typename CT> Callback_ScreenEx_ShowVideoPtr
newCallback_ScreenEx_ShowVideo(const IceUtil::Handle<T>& instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_ScreenEx_ShowVideo<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_ScreenEx_ShowVideoPtr
newCallback_ScreenEx_ShowVideo(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_ScreenEx_ShowVideo<T, CT>(instance, 0, excb, sentcb);
}

template<class T, typename CT> Callback_ScreenEx_ShowVideoPtr
newCallback_ScreenEx_ShowVideo(T* instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_ScreenEx_ShowVideo<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_ScreenEx_ShowVideoPtr
newCallback_ScreenEx_ShowVideo(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_ScreenEx_ShowVideo<T, CT>(instance, 0, excb, sentcb);
}

template<class T>
class CallbackNC_ScreenEx_Clean : public Callback_ScreenEx_Clean_Base, public ::IceInternal::OnewayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)();

    CallbackNC_ScreenEx_Clean(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallbackNC<T>(obj, cb, excb, sentcb)
    {
    }
};

template<class T> Callback_ScreenEx_CleanPtr
newCallback_ScreenEx_Clean(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_ScreenEx_Clean<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_ScreenEx_CleanPtr
newCallback_ScreenEx_Clean(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_ScreenEx_Clean<T>(instance, 0, excb, sentcb);
}

template<class T> Callback_ScreenEx_CleanPtr
newCallback_ScreenEx_Clean(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_ScreenEx_Clean<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_ScreenEx_CleanPtr
newCallback_ScreenEx_Clean(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_ScreenEx_Clean<T>(instance, 0, excb, sentcb);
}

template<class T, typename CT>
class Callback_ScreenEx_Clean : public Callback_ScreenEx_Clean_Base, public ::IceInternal::OnewayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const CT&);

    Callback_ScreenEx_Clean(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallback<T, CT>(obj, cb, excb, sentcb)
    {
    }
};

template<class T, typename CT> Callback_ScreenEx_CleanPtr
newCallback_ScreenEx_Clean(const IceUtil::Handle<T>& instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_ScreenEx_Clean<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_ScreenEx_CleanPtr
newCallback_ScreenEx_Clean(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_ScreenEx_Clean<T, CT>(instance, 0, excb, sentcb);
}

template<class T, typename CT> Callback_ScreenEx_CleanPtr
newCallback_ScreenEx_Clean(T* instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_ScreenEx_Clean<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_ScreenEx_CleanPtr
newCallback_ScreenEx_Clean(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_ScreenEx_Clean<T, CT>(instance, 0, excb, sentcb);
}

template<class T>
class CallbackNC_ScreenEx_ShowVip : public Callback_ScreenEx_ShowVip_Base, public ::IceInternal::OnewayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)();

    CallbackNC_ScreenEx_ShowVip(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallbackNC<T>(obj, cb, excb, sentcb)
    {
    }
};

template<class T> Callback_ScreenEx_ShowVipPtr
newCallback_ScreenEx_ShowVip(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_ScreenEx_ShowVip<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_ScreenEx_ShowVipPtr
newCallback_ScreenEx_ShowVip(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_ScreenEx_ShowVip<T>(instance, 0, excb, sentcb);
}

template<class T> Callback_ScreenEx_ShowVipPtr
newCallback_ScreenEx_ShowVip(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_ScreenEx_ShowVip<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_ScreenEx_ShowVipPtr
newCallback_ScreenEx_ShowVip(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_ScreenEx_ShowVip<T>(instance, 0, excb, sentcb);
}

template<class T, typename CT>
class Callback_ScreenEx_ShowVip : public Callback_ScreenEx_ShowVip_Base, public ::IceInternal::OnewayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const CT&);

    Callback_ScreenEx_ShowVip(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallback<T, CT>(obj, cb, excb, sentcb)
    {
    }
};

template<class T, typename CT> Callback_ScreenEx_ShowVipPtr
newCallback_ScreenEx_ShowVip(const IceUtil::Handle<T>& instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_ScreenEx_ShowVip<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_ScreenEx_ShowVipPtr
newCallback_ScreenEx_ShowVip(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_ScreenEx_ShowVip<T, CT>(instance, 0, excb, sentcb);
}

template<class T, typename CT> Callback_ScreenEx_ShowVipPtr
newCallback_ScreenEx_ShowVip(T* instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_ScreenEx_ShowVip<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_ScreenEx_ShowVipPtr
newCallback_ScreenEx_ShowVip(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_ScreenEx_ShowVip<T, CT>(instance, 0, excb, sentcb);
}

template<class T>
class CallbackNC_ScreenEx_ShowBarrage : public Callback_ScreenEx_ShowBarrage_Base, public ::IceInternal::OnewayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)();

    CallbackNC_ScreenEx_ShowBarrage(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallbackNC<T>(obj, cb, excb, sentcb)
    {
    }
};

template<class T> Callback_ScreenEx_ShowBarragePtr
newCallback_ScreenEx_ShowBarrage(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_ScreenEx_ShowBarrage<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_ScreenEx_ShowBarragePtr
newCallback_ScreenEx_ShowBarrage(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_ScreenEx_ShowBarrage<T>(instance, 0, excb, sentcb);
}

template<class T> Callback_ScreenEx_ShowBarragePtr
newCallback_ScreenEx_ShowBarrage(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_ScreenEx_ShowBarrage<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_ScreenEx_ShowBarragePtr
newCallback_ScreenEx_ShowBarrage(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_ScreenEx_ShowBarrage<T>(instance, 0, excb, sentcb);
}

template<class T, typename CT>
class Callback_ScreenEx_ShowBarrage : public Callback_ScreenEx_ShowBarrage_Base, public ::IceInternal::OnewayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const CT&);

    Callback_ScreenEx_ShowBarrage(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallback<T, CT>(obj, cb, excb, sentcb)
    {
    }
};

template<class T, typename CT> Callback_ScreenEx_ShowBarragePtr
newCallback_ScreenEx_ShowBarrage(const IceUtil::Handle<T>& instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_ScreenEx_ShowBarrage<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_ScreenEx_ShowBarragePtr
newCallback_ScreenEx_ShowBarrage(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_ScreenEx_ShowBarrage<T, CT>(instance, 0, excb, sentcb);
}

template<class T, typename CT> Callback_ScreenEx_ShowBarragePtr
newCallback_ScreenEx_ShowBarrage(T* instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_ScreenEx_ShowBarrage<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_ScreenEx_ShowBarragePtr
newCallback_ScreenEx_ShowBarrage(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_ScreenEx_ShowBarrage<T, CT>(instance, 0, excb, sentcb);
}

template<class T>
class CallbackNC_Config_SetSystemVolume : public Callback_Config_SetSystemVolume_Base, public ::IceInternal::OnewayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)();

    CallbackNC_Config_SetSystemVolume(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallbackNC<T>(obj, cb, excb, sentcb)
    {
    }
};

template<class T> Callback_Config_SetSystemVolumePtr
newCallback_Config_SetSystemVolume(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Config_SetSystemVolume<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Config_SetSystemVolumePtr
newCallback_Config_SetSystemVolume(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Config_SetSystemVolume<T>(instance, 0, excb, sentcb);
}

template<class T> Callback_Config_SetSystemVolumePtr
newCallback_Config_SetSystemVolume(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Config_SetSystemVolume<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Config_SetSystemVolumePtr
newCallback_Config_SetSystemVolume(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Config_SetSystemVolume<T>(instance, 0, excb, sentcb);
}

template<class T, typename CT>
class Callback_Config_SetSystemVolume : public Callback_Config_SetSystemVolume_Base, public ::IceInternal::OnewayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const CT&);

    Callback_Config_SetSystemVolume(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallback<T, CT>(obj, cb, excb, sentcb)
    {
    }
};

template<class T, typename CT> Callback_Config_SetSystemVolumePtr
newCallback_Config_SetSystemVolume(const IceUtil::Handle<T>& instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Config_SetSystemVolume<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Config_SetSystemVolumePtr
newCallback_Config_SetSystemVolume(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Config_SetSystemVolume<T, CT>(instance, 0, excb, sentcb);
}

template<class T, typename CT> Callback_Config_SetSystemVolumePtr
newCallback_Config_SetSystemVolume(T* instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Config_SetSystemVolume<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Config_SetSystemVolumePtr
newCallback_Config_SetSystemVolume(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Config_SetSystemVolume<T, CT>(instance, 0, excb, sentcb);
}

template<class T>
class CallbackNC_Config_GetSystemVolume : public Callback_Config_GetSystemVolume_Base, public ::IceInternal::TwowayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)(::Ice::Int);

    CallbackNC_Config_GetSystemVolume(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), _response(cb)
    {
    }

    virtual void completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::Robot::ConfigPrx __proxy = ::Robot::ConfigPrx::uncheckedCast(__result->getProxy());
        ::Ice::Int __ret;
        try
        {
            __ret = __proxy->end_GetSystemVolume(__result);
        }
        catch(const ::Ice::Exception& ex)
        {
            ::IceInternal::CallbackNC<T>::exception(__result, ex);
            return;
        }
        if(_response)
        {
            (::IceInternal::CallbackNC<T>::_callback.get()->*_response)(__ret);
        }
    }

    private:

    Response _response;
};

template<class T> Callback_Config_GetSystemVolumePtr
newCallback_Config_GetSystemVolume(const IceUtil::Handle<T>& instance, void (T::*cb)(::Ice::Int), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Config_GetSystemVolume<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Config_GetSystemVolumePtr
newCallback_Config_GetSystemVolume(T* instance, void (T::*cb)(::Ice::Int), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Config_GetSystemVolume<T>(instance, cb, excb, sentcb);
}

template<class T, typename CT>
class Callback_Config_GetSystemVolume : public Callback_Config_GetSystemVolume_Base, public ::IceInternal::TwowayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(::Ice::Int, const CT&);

    Callback_Config_GetSystemVolume(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), _response(cb)
    {
    }

    virtual void completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::Robot::ConfigPrx __proxy = ::Robot::ConfigPrx::uncheckedCast(__result->getProxy());
        ::Ice::Int __ret;
        try
        {
            __ret = __proxy->end_GetSystemVolume(__result);
        }
        catch(const ::Ice::Exception& ex)
        {
            ::IceInternal::Callback<T, CT>::exception(__result, ex);
            return;
        }
        if(_response)
        {
            (::IceInternal::Callback<T, CT>::_callback.get()->*_response)(__ret, CT::dynamicCast(__result->getCookie()));
        }
    }

    private:

    Response _response;
};

template<class T, typename CT> Callback_Config_GetSystemVolumePtr
newCallback_Config_GetSystemVolume(const IceUtil::Handle<T>& instance, void (T::*cb)(::Ice::Int, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Config_GetSystemVolume<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Config_GetSystemVolumePtr
newCallback_Config_GetSystemVolume(T* instance, void (T::*cb)(::Ice::Int, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Config_GetSystemVolume<T, CT>(instance, cb, excb, sentcb);
}

template<class T>
class CallbackNC_Config_SetSystemCmd : public Callback_Config_SetSystemCmd_Base, public ::IceInternal::OnewayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)();

    CallbackNC_Config_SetSystemCmd(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallbackNC<T>(obj, cb, excb, sentcb)
    {
    }
};

template<class T> Callback_Config_SetSystemCmdPtr
newCallback_Config_SetSystemCmd(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Config_SetSystemCmd<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Config_SetSystemCmdPtr
newCallback_Config_SetSystemCmd(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Config_SetSystemCmd<T>(instance, 0, excb, sentcb);
}

template<class T> Callback_Config_SetSystemCmdPtr
newCallback_Config_SetSystemCmd(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Config_SetSystemCmd<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Config_SetSystemCmdPtr
newCallback_Config_SetSystemCmd(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Config_SetSystemCmd<T>(instance, 0, excb, sentcb);
}

template<class T, typename CT>
class Callback_Config_SetSystemCmd : public Callback_Config_SetSystemCmd_Base, public ::IceInternal::OnewayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const CT&);

    Callback_Config_SetSystemCmd(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallback<T, CT>(obj, cb, excb, sentcb)
    {
    }
};

template<class T, typename CT> Callback_Config_SetSystemCmdPtr
newCallback_Config_SetSystemCmd(const IceUtil::Handle<T>& instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Config_SetSystemCmd<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Config_SetSystemCmdPtr
newCallback_Config_SetSystemCmd(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Config_SetSystemCmd<T, CT>(instance, 0, excb, sentcb);
}

template<class T, typename CT> Callback_Config_SetSystemCmdPtr
newCallback_Config_SetSystemCmd(T* instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Config_SetSystemCmd<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Config_SetSystemCmdPtr
newCallback_Config_SetSystemCmd(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Config_SetSystemCmd<T, CT>(instance, 0, excb, sentcb);
}

template<class T>
class CallbackNC_Pub_Notify : public Callback_Pub_Notify_Base, public ::IceInternal::OnewayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)();

    CallbackNC_Pub_Notify(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallbackNC<T>(obj, cb, excb, sentcb)
    {
    }
};

template<class T> Callback_Pub_NotifyPtr
newCallback_Pub_Notify(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Pub_Notify<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Pub_NotifyPtr
newCallback_Pub_Notify(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Pub_Notify<T>(instance, 0, excb, sentcb);
}

template<class T> Callback_Pub_NotifyPtr
newCallback_Pub_Notify(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Pub_Notify<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Pub_NotifyPtr
newCallback_Pub_Notify(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Pub_Notify<T>(instance, 0, excb, sentcb);
}

template<class T, typename CT>
class Callback_Pub_Notify : public Callback_Pub_Notify_Base, public ::IceInternal::OnewayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const CT&);

    Callback_Pub_Notify(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallback<T, CT>(obj, cb, excb, sentcb)
    {
    }
};

template<class T, typename CT> Callback_Pub_NotifyPtr
newCallback_Pub_Notify(const IceUtil::Handle<T>& instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Pub_Notify<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Pub_NotifyPtr
newCallback_Pub_Notify(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Pub_Notify<T, CT>(instance, 0, excb, sentcb);
}

template<class T, typename CT> Callback_Pub_NotifyPtr
newCallback_Pub_Notify(T* instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Pub_Notify<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Pub_NotifyPtr
newCallback_Pub_Notify(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Pub_Notify<T, CT>(instance, 0, excb, sentcb);
}

template<class T>
class CallbackNC_Session_List : public Callback_Session_List_Base, public ::IceInternal::TwowayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)(const ::Ice::StringSeq&);

    CallbackNC_Session_List(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), _response(cb)
    {
    }

    virtual void completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::Robot::SessionPrx __proxy = ::Robot::SessionPrx::uncheckedCast(__result->getProxy());
        ::Ice::StringSeq sList;
        try
        {
            __proxy->end_List(sList, __result);
        }
        catch(const ::Ice::Exception& ex)
        {
            ::IceInternal::CallbackNC<T>::exception(__result, ex);
            return;
        }
        if(_response)
        {
            (::IceInternal::CallbackNC<T>::_callback.get()->*_response)(sList);
        }
    }

    private:

    Response _response;
};

template<class T> Callback_Session_ListPtr
newCallback_Session_List(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::Ice::StringSeq&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Session_List<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Session_ListPtr
newCallback_Session_List(T* instance, void (T::*cb)(const ::Ice::StringSeq&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Session_List<T>(instance, cb, excb, sentcb);
}

template<class T, typename CT>
class Callback_Session_List : public Callback_Session_List_Base, public ::IceInternal::TwowayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const ::Ice::StringSeq&, const CT&);

    Callback_Session_List(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), _response(cb)
    {
    }

    virtual void completed(const ::Ice::AsyncResultPtr& __result) const
    {
        ::Robot::SessionPrx __proxy = ::Robot::SessionPrx::uncheckedCast(__result->getProxy());
        ::Ice::StringSeq sList;
        try
        {
            __proxy->end_List(sList, __result);
        }
        catch(const ::Ice::Exception& ex)
        {
            ::IceInternal::Callback<T, CT>::exception(__result, ex);
            return;
        }
        if(_response)
        {
            (::IceInternal::Callback<T, CT>::_callback.get()->*_response)(sList, CT::dynamicCast(__result->getCookie()));
        }
    }

    private:

    Response _response;
};

template<class T, typename CT> Callback_Session_ListPtr
newCallback_Session_List(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::Ice::StringSeq&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Session_List<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Session_ListPtr
newCallback_Session_List(T* instance, void (T::*cb)(const ::Ice::StringSeq&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Session_List<T, CT>(instance, cb, excb, sentcb);
}

template<class T>
class CallbackNC_Live_RemoteRecvStart : public Callback_Live_RemoteRecvStart_Base, public ::IceInternal::OnewayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)();

    CallbackNC_Live_RemoteRecvStart(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallbackNC<T>(obj, cb, excb, sentcb)
    {
    }
};

template<class T> Callback_Live_RemoteRecvStartPtr
newCallback_Live_RemoteRecvStart(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Live_RemoteRecvStart<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Live_RemoteRecvStartPtr
newCallback_Live_RemoteRecvStart(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Live_RemoteRecvStart<T>(instance, 0, excb, sentcb);
}

template<class T> Callback_Live_RemoteRecvStartPtr
newCallback_Live_RemoteRecvStart(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Live_RemoteRecvStart<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Live_RemoteRecvStartPtr
newCallback_Live_RemoteRecvStart(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Live_RemoteRecvStart<T>(instance, 0, excb, sentcb);
}

template<class T, typename CT>
class Callback_Live_RemoteRecvStart : public Callback_Live_RemoteRecvStart_Base, public ::IceInternal::OnewayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const CT&);

    Callback_Live_RemoteRecvStart(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallback<T, CT>(obj, cb, excb, sentcb)
    {
    }
};

template<class T, typename CT> Callback_Live_RemoteRecvStartPtr
newCallback_Live_RemoteRecvStart(const IceUtil::Handle<T>& instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Live_RemoteRecvStart<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Live_RemoteRecvStartPtr
newCallback_Live_RemoteRecvStart(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Live_RemoteRecvStart<T, CT>(instance, 0, excb, sentcb);
}

template<class T, typename CT> Callback_Live_RemoteRecvStartPtr
newCallback_Live_RemoteRecvStart(T* instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Live_RemoteRecvStart<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Live_RemoteRecvStartPtr
newCallback_Live_RemoteRecvStart(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Live_RemoteRecvStart<T, CT>(instance, 0, excb, sentcb);
}

template<class T>
class CallbackNC_Live_RemoteRecvStop : public Callback_Live_RemoteRecvStop_Base, public ::IceInternal::OnewayCallbackNC<T>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)();

    CallbackNC_Live_RemoteRecvStop(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallbackNC<T>(obj, cb, excb, sentcb)
    {
    }
};

template<class T> Callback_Live_RemoteRecvStopPtr
newCallback_Live_RemoteRecvStop(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Live_RemoteRecvStop<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Live_RemoteRecvStopPtr
newCallback_Live_RemoteRecvStop(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Live_RemoteRecvStop<T>(instance, 0, excb, sentcb);
}

template<class T> Callback_Live_RemoteRecvStopPtr
newCallback_Live_RemoteRecvStop(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Live_RemoteRecvStop<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_Live_RemoteRecvStopPtr
newCallback_Live_RemoteRecvStop(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Live_RemoteRecvStop<T>(instance, 0, excb, sentcb);
}

template<class T, typename CT>
class Callback_Live_RemoteRecvStop : public Callback_Live_RemoteRecvStop_Base, public ::IceInternal::OnewayCallback<T, CT>
{
public:

    typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const CT&);

    Callback_Live_RemoteRecvStop(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallback<T, CT>(obj, cb, excb, sentcb)
    {
    }
};

template<class T, typename CT> Callback_Live_RemoteRecvStopPtr
newCallback_Live_RemoteRecvStop(const IceUtil::Handle<T>& instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Live_RemoteRecvStop<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Live_RemoteRecvStopPtr
newCallback_Live_RemoteRecvStop(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Live_RemoteRecvStop<T, CT>(instance, 0, excb, sentcb);
}

template<class T, typename CT> Callback_Live_RemoteRecvStopPtr
newCallback_Live_RemoteRecvStop(T* instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Live_RemoteRecvStop<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_Live_RemoteRecvStopPtr
newCallback_Live_RemoteRecvStop(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Live_RemoteRecvStop<T, CT>(instance, 0, excb, sentcb);
}

}

#include <IceUtil/PopDisableWarnings.h>


#endif // TMROBOTDEF_H
